How to use the chai.expect function in chai

.test(({instance}) => {
        let head = instance.props.children[0],
          tableRows = instance.props.children[1]
        expect(head.props).to.not.be.undefined
        expect(tableRows.props).to.not.be.undefined
        expect(head.props.row).to.equal(rows[0])
        expect(tableRows.props.rows).to.equal(rows)
      })
    })

it('converts input to string', () => {
    expect(urlSlug.convert(123))
      .to.be.equal('123')
  })

it('测试 labels', function() {
    const labelsGroup = xAxis.get('labelsGroup');
    expect(labelsGroup).not.to.null;
    expect(labelsGroup.getCount()).to.equal(5);
  });

it('May create new instance of Circle', function () {
        let circle = new Circle(new Point(0,0), 1);
        expect(circle).to.be.an.instanceof(Circle);
    });
    it('Constructor Circle(pt, r) creates new circle', function() {

it('should set the date option', () => {
    const state = formReducer(undefined, {
      type: 'DATE_OPTION_CHANGED',
      dateOption: '1yr'
    });

    expect(state.dateOption).to.equal('1yr');
  });

it('should be available as named exports', () => {
		expect(h).to.be.a('function');
		expect(Component).to.be.a('function');
		expect(render).to.be.a('function');
		expect(rerender).to.be.a('function');
		expect(options).to.exist.and.be.an('object');
	});
});

it('should render input without filterText', function () {
      const wrap = shallow();
      const input = wrap.find('input').first();
      expect(input.props().placeholder).to.equal('Filter');
    });

                    .then(() => expect(actual).to.deep.equal(expected));
            });

boltwallConfig: {
            caveatSatisfiers: [satisfier, invalidSatisfyFinal],
          },
        }
        const invalidReq2 = {
          boltwallConfig: {
            caveatSatisfiers: [satisfier, invalidSatisfyPrev],
          },
        }
        const invalidateFinal = (): boolean =>
          verifyCaveats(caveats, invalidReq1 as Request)
        const invalidatePrev = (): boolean =>
          verifyCaveats(caveats, invalidReq2 as Request)

        expect(invalidateFinal()).to.be.false
        expect(invalidatePrev()).to.be.false
      })
    })

const comparePaths = (path1, path2) => {
  if (process.platform === 'win32') {
    path1 = path1.toLowerCase()
    path2 = path2.toLowerCase()
  }
  expect(path1).to.equal(path2)
}