it("object assignment", () => {
  const data = { one: 1 };
  data["two"] = 2;
  expect(data).toEqual({ one: 1, two: 2 });
});

/**
 * @param expectation 简短的对此测试样例的描述
 * @param assertion 一个包裹单元测试断言及相关逻辑的函数
 */
function it(expectation: string, assertion: (done: () => void) => void);

it("does a thing", async function () {
  // Will fail if doSomethingThatMightThrow throws.
  doSomethingThatMightThrow();

  // Will fail if the promise returned by
  // asyncFunctionThatMightFail is rejected.
  const value = await asyncFunctionThatMightFail();
  // ...
});

it("does a thing", function () {
  // Since `.then` propagates rejections, this test will fail if
  // the promise returned by asyncFunctionThatMightFail is rejected.
  return asyncFunctionThatMightFail().then(function (value) {
    // ...
  });
});

it("does a thing", function (done) {
  someAsyncFunction(function (result) {
    expect(result).toEqual(someExpectedValue);
    done();
  });
});

/**
 * @param description 此测试集合的描述
 * @param specDefinitions 测试集合
 */
function describe(description: string, specDefinitions: () => void);

describe("HeroesService (with spies)", () => {
  it("should return expected heroes (HttpClient called once)", (done: DoneFn) => {
    // Some statement
  });

  it("should return an error when the server returns a 404", (done: DoneFn) => {
    // Some statement
  });
});

describe('HeroesService (with spies)', () => {
  let httpClientSpy: { get: jasmine.Spy };
  let heroService: HeroService;

  beforeEach(() => {
    // TODO: spy on other methods too
  });

  it('should return expected heroes (HttpClient called once)', (done: DoneFn) => {
    // Some statement
  });

  describe('HeroesService (with spies)', () => {
    it('should return an error when the server returns a 404', (done: DoneFn) => {
	  // Some statement
    });
  }
});

TestBed.configureTestingModule({
  imports: [CommonModule, FormsModule, ThyAutocompleteModule, ThyOptionModule],
  declarations: declarations,
  providers: [UpdateHostClassService],
}).compileComponents();

@Injectable({
  providedIn: "root",
})
export class ThyScrollService {
  private document: Document;

  constructor(@Inject(DOCUMENT) document: any) {
    this.document = document;
  }

  setScrollTop(element: Element | Window, topValue: number = 0): void {
    if (element === window) {
      this.document.body.scrollTop = topValue;
      this.document.documentElement.scrollTop = topValue;
    } else {
      (element as Element).scrollTop = topValue;
    }
  }
}

injector = TestBed.configureTestingModule({
  providers: [ThyScrollService, { provide: DOCUMENT, useClass: MockDocument }],
});

class MockDocument {
  body = new MockElement();
  documentElement = new MockDocumentElement();
}
class MockDocumentElement {}
class MockElement {}

let fixture: ComponentFixture<BasicSelectComponent>;
beforeEach(fakeAsync(() => {
  fixture = TestBed.createComponent(BasicTestComponent);
  fixture.detectChanges();
}));

const trigger = fixture.debugElement.query(By.css("input")).nativeElement;

// Match elements by the given CSS selector.
// css 可以传入css选择器，如标签名称、class name等等
static css(selector: string): Predicate<DebugElement>;
// Match elements that have the given directive present.
// directive 可以传入组件或者指令的类型
static directive(type: Type<any>): Predicate<DebugElement>;

it("should open the panel when trigger focused", fakeAsync(() => {
  dispatchFakeEvent(trigger, "focusin");
  fixture.detectChanges();
  tick(500);
  expect(fixture.componentInstance.autocomplete.isOpened).toBe(true);
  expect(overlayContainerElement.textContent).toContain("Steak");
}));

it(`should get member when assign uid`, fakeAsync(() => {
  testComponent.uid = teamMock.members[0].uid;
  const spy = spyOn(userStore, "getUser");
  spy.and.returnValue(teamMock.members[0]);
  fixture.detectChanges();
  tick();
  fixture.detectChanges();
  expect(singleSelectHtmlElement.innerText).toContain(teamMock.members[0].display_name);
}));

const closedSpy = jasmine.createSpy("closed event spy callback");

fixture.componentInstance.autocomplete.thyClosed.subscribe(() => {
  closedSpy();
});

dispatchFakeEvent(trigger, "focusin");
fixture.detectChanges();
tick(500);
const option = overlayContainerElement.querySelector("thy-option") as HTMLElement;
option.click();
fixture.detectChanges();

expect(closedSpy).toHaveBeenCalled();

const closedSpy = spyOn(fixture.componentInstance, "onClosed");

it("should emit opend event when the panel opened", fakeAsync(() => {
  dispatchFakeEvent(trigger, "focus");
  fixture.detectChanges();
  tick(500);
  expect(fixture.componentInstance.openedSpy).toHaveBeenCalled();
}));

export interface ModifierKeys {
  control?: boolean;
  alt?: boolean;
  shift?: boolean;
  meta?: boolean;
}

/**
 * Shorthand to dispatch a keyboard event with a specified key code.
 * @docs-private
 */
export function dispatchKeyboardEvent(
  node: Node,
  type: string,
  keyCode?: number,
  key?: string,
  target?: Element,
  modifiers?: ModifierKeys
): KeyboardEvent {
  return dispatchEvent(node, createKeyboardEvent(type, keyCode, key, target, modifiers)) as KeyboardEvent;
}

import { Component }   from '@angular/core';

@Component({
  selector: 'app-banner',
  template: '<h1>{{title}}</h1>'
})
export class BannerComponent {
  title = 'Test Tour of Heroes';
}

let comp:    BannerComponent;
let fixture: ComponentFixture<BannerComponent\>;
let de:      DebugElement;
let el:      HTMLElement;

describe('BannerComponent', () => {
  beforeEach(() => {
    TestBed.configureTestingModule({
      declarations: [ BannerComponent ], // declare the test component
    });

    fixture = TestBed.createComponent(BannerComponent);

    comp = fixture.componentInstance; // BannerComponent test instance

    // query for the title <h1> by CSS element selector
    de = fixture.debugElement.query(By.css('h1'));
    el = de.nativeElement;

  });
});

userServiceStub = {
  isLoggedIn: true,
  user: { name: 'Test User'}
};

beforeEach(() => {
  // stub UserService for test purposes
  userServiceStub = {
    isLoggedIn: true,
    user: { name: "Test User" },
  };

  TestBed.configureTestingModule({
    declarations: [WelcomeComponent],
    // 重点
    providers: [{ provide: UserService, useValue: userServiceStub }],
  });

  fixture = TestBed.createComponent(WelcomeComponent);
  comp = fixture.componentInstance;

  // UserService from the root injector
  // 重点
  userService = TestBed.get(UserService);

  //  get the "welcome" element by CSS selector (e.g., by class name)
  de = fixture.debugElement.query(By.css(".welcome"));
  el = de.nativeElement;
});

spy = spyOn(remoteService, "getTodos").and.returnValues([Promise.resolve(datas), Promise.resolve(datas2)]);

@Component({
  selector: "twain-quote",
  template: '<p class="twain"><i>{{quote}}</i></p>',
})
export class TwainComponent implements OnInit {
  intervalId: number;
  quote = "...";
  constructor(private twainService: TwainService) {}

  ngOnInit(): void {
    this.twainService.getQuote().then((quote) => (this.quote = quote));
  }
}

it("should show quote after getQuote promise (async)", async(() => {
  fixture.detectChanges();

  fixture.whenStable().then(() => {
    // wait for async getQuote
    fixture.detectChanges(); // update view with quote
    expect(el.textContent).toBe(testQuote);
  });
}));

it("should show quote after getQuote promise (fakeAsync)", fakeAsync(() => {
  fixture.detectChanges();
  tick(); // wait for async getQuote
  fixture.detectChanges(); // update view with quote
  expect(el.textContent).toBe(testQuote);
}));

it("should show quote after getQuote promise (done)", (done) => {
  fixture.detectChanges();

  // get the spy promise and wait for it to resolve
  spy.calls.mostRecent().returnValue.then(() => {
    fixture.detectChanges(); // update view with quote
    expect(el.textContent).toBe(testQuote);
    done();
  });
});

// async beforeEach
beforeEach(async(() => {
  TestBed.configureTestingModule({
    declarations: [DashboardHeroComponent],
  }).compileComponents(); // compile template and css
}));

// async beforeEach
beforeEach(async(() => {
  TestBed.configureTestingModule({
    declarations: [DashboardHeroComponent],
  }).compileComponents(); // compile template and css
}));

// synchronous beforeEach
beforeEach(() => {
  fixture = TestBed.createComponent(DashboardHeroComponent);
  comp = fixture.componentInstance;
  heroEl = fixture.debugElement.query(By.css(".hero")); // find hero element

  // pretend that it was wired to something that supplied a hero
  expectedHero = new Hero(42, "Test Name");
  comp.hero = expectedHero;
  fixture.detectChanges(); // trigger initial data binding
});

// pretend that it was wired to something that supplied a hero
expectedHero = new Hero(42, "Test Name");
comp.hero = expectedHero;

it("should raise selected event when clicked", () => {
  let selectedHero: Hero;
  comp.selected.subscribe((hero: Hero) => (selectedHero = hero));

  heroEl.triggerEventHandler("click", null);
  expect(selectedHero).toBe(expectedHero);
});