const can = {
    name: 'pamplemousse', // 그레이프 프루트
    ounces: 12,
};
 
describe('the can', () => {
    test('12 온스', () => {
        expect(can.ounces).toBe(12); // can의 내용물의 질량이 12온스인지 테스트
    });
 
    test('세련된 이름이 있다', () => {
        expect(can.name).toBe('pamplemousse'); // can의 세련된 이름이 'pamplemousse' 인지 확인합니다
    });
});

const can1 = {
    flavor: 'grapefruit',
    ounces: 12,
};
const can2 = {
    flavor: 'grapefruit',
    ounces: 12,
};
 
describe('the La Croix cans on my desk', () => {
    test('have all the same properties', () => {
        expect(can1).toEqual(can2); // Object 구조가 동일하므로 테스트 통과
    });
    test('are not the exact same can', () => {
        expect(can1).not.toBe(can2); // 같은 Object 가 아니므로 테스트 통과
    });
});

function bloop() {
    return null;
}
 
test('bloop returns null', () => {
    expect(bloop()).toBeNull();
});

expect([1, 2, 3]).toHaveLength(3);
expect('abc').toHaveLength(3);
expect(' ').not.toHaveLength(5);

// 테스트 할 주택 기능이 포함 된 객체
const houseForSale = {
  bath: true,
  bedrooms: 4,
  kitchen: {
    amenities: ['oven', 'stove', 'washer'],
    area: 20,
    wallColor: 'white',
    'nice.oven': true,
  },
  'ceiling.height': 2,
};
 
test('this house has my desired features', () => {
  // Example Referencing
  expect(houseForSale).toHaveProperty('bath');
  expect(houseForSale).toHaveProperty('bedrooms', 4);
  expect(houseForSale).not.toHaveProperty('pool');
 
  // 점 표기법을 사용한 깊은 참조
  expect(houseForSale).toHaveProperty('kitchen.area', 20);
  expect(houseForSale).toHaveProperty('kitchen.amenities', [
    'oven',
    'stove',
    'washer',
  ]);
 
  expect(houseForSale).not.toHaveProperty('kitchen.open');
 
  // keyPath를 포함하는 배열을 사용하는 깊은 참조
  expect(houseForSale).toHaveProperty(['kitchen', 'area'], 20);
  expect(houseForSale).toHaveProperty(
    ['kitchen', 'amenities'],
    ['oven', 'stove', 'washer'],
  );
  expect(houseForSale).toHaveProperty(['kitchen', 'amenities', 0], 'oven');
  expect(houseForSale).toHaveProperty(['kitchen', 'nice.oven']);
  expect(houseForSale).not.toHaveProperty(['kitchen', 'open']);
 
  // 키 자체에 점이있는 키 참조
  expect(houseForSale).toHaveProperty(['ceiling.height'], 'tall');
});

// 검증대상 함수
function drinkAll(callback, flavor) {
    if (flavour !== 'octopus') {
        callback(flavor);
    }
}
 
describe('drinkAll', () => {
    test ('레몬맛이 나는 음료', () => {
        const drink = jest.fn(); // 모의 callback 함수를 생성한다.
        drinkAll(drink, 'lemon');
        expect(drink).toHaveBeenCalled(); // drink 함수에 'lemon' 을 적용했을때 callback 함수가 발동하는지 체크
    });
    test ('문어맛이 나는 음료는 마시지 않는다', () => {
        const drink = jest.fn();
        drinkAll(drink, 'octopus');
        expect(drink).not.toHaveBeenCalled(); // .not 을 사용해서 부정값이 참임을 확인합니다.
    });
});

// 검증할 simulatePresses 함수
const simulatePresses = (callback) => {
    callback({ x: 3, y:5 });
};
 
 
test ('onPress가 옳은 일을하고 있습니다.', () => {
    const onPress = jest.fn();
    simulatePresses(onPress);
    expect(onPress).toBeCallWith(
        expect.objectContaining({ // onPress 가 동작할때 수신되는 객체값에 아래의 x, y 의 값이 포함되는지 테스트
            x: expect.any(Number), // Number 타입인지 검증
            y: expect.any(Number), // Number 타입인지 검증
        });
    );
});

describe('arrayContaining', () => {
    const expected = ['Alice', 'Bob'];
    it ('수신된 요소가 예상 요소를 포함하고 있으면 일치합니다.', () => {
        expect(['Alice', 'Bob', 'Eve']).toEqual(expect.arrayContaining(expected));
    });
    it ('수신된 요소가 예상 요소를 포함하지 않으면 일치하지 않습니다.', () => {
        expect(['Bob', 'Eve']).not.toEqual(expect.arrayContaining(expected));
    });
});

describe('Beware of a misunderstanding! A sequence of dice rolls', () => {
    const expected = [1, 2, 3, 4, 5, 6];
    it ('예기치 않은 숫자 7이 있지만 일치합니다.', () => {
        expect([4, 1, 6, 7, 3, 5, 2, 5, 4, 6]).toEqual( expect.arrayContaining(expected) ); // 수신요소에는 예상요소의 7이 없지만 하위 요소를 모두 포함하므로 일치한다.
    });
    it ('예상되는 번호 2가 없으면 일치하지 않습니다.', () => {
        expect([4, 1, 6, 7, 3, 5, 7, 5, 4, 6]).not.toEqual( expect.arrayContaining(expected) ); // 예상요소에 수신요소의 2가 포함되어있지 않아 일치하지 않는다.
    });
});

describe('arrayContining 안에서 stringMatching', () => {
  const expected = [
    expect.stringMatching(/^Alic/), // 특정 요소의 값이 regexp 에 정의된 규칙에 일치하는지 판단. 예로 Alic.. 라는 단어로 테스트하면 일치
    expect.stringMatching(/^[BR]ob/), // 특정 요소의 값이 regexp 에 정의된 규칙에 일치하는지 판단. 예로 Bob.. 또는 Rob... 라는 단어로 테스트하면 일치
  ];
  it ('추가 요소가 포함된 경우에도 일치합니다.', () => {
    expect(['Alice', 'Roberto', 'Evelina']).toEqual(
      expect.arrayContaining(expected), // arrayContaining 으로 ['Alice', 'Roberto', 'Evelina'] 에 /^Alic/ 또는 /^[BR]ob/ 의 문자열을 포함하는지를 테스트
    );
  });
  it ('수신된 요소가 예상 요소를 포함하지 않으면 일치하지 않습니다.', () => {
    expect(['Roberto', 'Evelina']).not.toEqual(
      expect.arrayContaining(expected), // 검증 array 요소안에는 expected의 요소(/^Alic/)가 일치하지 않습니다.  not.toEqual 이므로 테스트는 일치
    );
  });
});