describe('running validate() with correct values set', () =>
		{
			const validationGroup = new ValidationGroup(values =>
			{
				const fullName = values['first-name'] + ' ' + values['last-name'];
				return (fullName === 'John Doe');
			});

			const firstNameField = new Field('0', null);
			firstNameField.name = 'first-name';
			firstNameField.value = ko.observable();
			firstNameField.groups = validationGroup;

			const lastNameField = new Field('1', null);
			lastNameField.name = 'last-name';
			lastNameField.value = ko.observable();
			lastNameField.groups = validationGroup;

			//noinspection TypeScriptUnresolvedFunction
			firstNameField.value('John');
			//noinspection TypeScriptUnresolvedFunction
			lastNameField.value('Doe');
			it('should resolve with true', () =>
			{
				const validation = validationGroup.validate();
				return expect(validation).to.eventually.equal(true);
			});
		});

    constructor(language: string, framework: string) {
        this.language = ko.observable(language);
        this.framework = ko.observable(framework);

        this.ebalo = ko.computed(() => { return 'idi nahui ' + this.language; }, self);
        console.warn('Ebososina roompenji');
    }

  /**
   * ctor
   * */
  public constructor(_properties: IPropertyPaneViewSelectorFieldPropsInternal) {
    this._properties = _properties;
    this._context = _properties.wpContext;
    this._listId = _properties.listId;
    this._viewId = _properties.viewId;
    this.listLabel = _properties.listLabel;
    this.viewLabel = _properties.viewLabel;
    this.currentList = ko.observable<string>(this._listId);
    this.currentView = ko.observable<string>(this._viewId);
    this.noListSelection = ko.observable<boolean>(this._listId == '-1');

    // subscribing on changes in lists dropdown
    this.currentList.subscribe((value) => {
      const oldListId: string = this._listId;
      this._listId = value;
      this._initViews().then(() => {
        this.noListSelection(this._listId == '-1');
      });

      this._firePropertyChange();

    });

    // subscribing on changes in view dropdown
    this.currentView.subscribe((value) => {
      const oldViewId: string = this._viewId;
      this._viewId = value;
      this._firePropertyChange();
    });

    this.lists = ko.observableArray<IDropdownOption>();
    this.views = ko.observableArray<IDropdownOption>();

    this._model = new PropertyPaneViewSelectorModel(this._context);
  }

 constructor(){
     this.name = ko.observable<string>("");
     this.age = ko.observable<number>(null);
     this.contacts = ko.observableArray<Person>([]);
     this.itemToAdd = null;
     this.display = ko.observable<string>("");
 }

 constructor(firstname: string, lastname: string){
     this.firstName = ko.observable(firstname);
     this.lastName =  ko.observable(lastname);
     this.fullName = ko.computed<string>(() => {
         return this.firstName() + " " + this.lastName();
     });
 }

export default function fromJS(
  obj: any,
  mapArraysDeep: boolean = false,
  _parentIsArray: boolean = false
): KnockoutObservable<any> | KnockoutObservableTree {
  let obs: KnockoutObservable<any> | KnockoutObservableTree

  if (ko.isObservable(obj)) {
    obs = obj
  } else if (obj instanceof Array) {
    const _arr = []
    for (let i = 0; i < obj.length; i++) {
      _arr[i] = fromJS(obj[i], mapArraysDeep, true)
    }
    obs = ko.observableArray(_arr)
  } else if (obj instanceof Date || obj instanceof RegExp) {
    obs = ko.observable(obj)
  } else if (obj instanceof Function) {
    obs = obj
  } else if (obj instanceof Object) {
    obs = {}
    for (const p in obj) {
      obs[p] = fromJS(obj[p], mapArraysDeep)
    }
  } else {
    obs = _parentIsArray && !mapArraysDeep ? obj : ko.observable(obj)
  }

  return obs
}

export function createNote(): Note {
    return {
        title: ko.observable("Note #1"),
        date: ko.observable(Date.now()),
        content: ko.observable("This is the content of Note #1")
    };
}

  it('should not create unnecessary subscriptions with computeds', function() {
    const kObsA = ko.observable("a");
    const kObsB = ko.observable("b");
    const spyA = sinon.spy((a: any) => a);
    const spyB = sinon.spy((a: any) => a);
    const gObsA = computed((use) => spyA(use(kObsA)));
    const gObsB = pureComputed((use) => spyB(use(kObsB)));

    // A computed notices a change immediately.
    assertResetSingleCall(spyA, undefined, "a");
    assert.equal(gObsA.get(), "a");
    kObsA("A");
    assertResetSingleCall(spyA, undefined, "A");
    assert.equal(gObsA.get(), "A");
    sinon.assert.notCalled(spyA);

    // pureComputed notices a change only when looked at.
    sinon.assert.notCalled(spyB);
    assert.equal(gObsB.get(), "b");
    assertResetSingleCall(spyB, undefined, "b");
    kObsB("B");
    sinon.assert.notCalled(spyB);
    assert.equal(gObsB.get(), "B");
    assertResetSingleCall(spyB, undefined, "B");

    // This is the crux of the matter: kObsB does not have a subscription.
    assert.equal(kObsA.getSubscriptionsCount(), 1);
    assert.equal(kObsB.getSubscriptionsCount(), 0);     // pureComputed doesn't subscribe when inactive

    // Now subscribe to both gObs computeds.
    const spyA2 = sinon.spy((a: any) => a);
    const spyB2 = sinon.spy((a: any) => a);
    const lisA = gObsA.addListener(spyA2);
    const lisB = gObsB.addListener(spyB2);
    assertResetSingleCall(spyB, undefined, "B");

    // Now pureComputed acts as computed and subscribes too.
    assert.equal(kObsA.getSubscriptionsCount(), 1);
    assert.equal(kObsB.getSubscriptionsCount(), 1);

    kObsA("aa");
    assertResetSingleCall(spyA, undefined, "aa");
    assertResetSingleCall(spyA2, undefined, "aa", "A");
    kObsB("bb");
    assertResetSingleCall(spyB, undefined, "bb");
    assertResetSingleCall(spyB2, undefined, "bb", "B");

    // When we unsubscribe, count should go back to 0.
    lisA.dispose();
    lisB.dispose();
    assert.equal(kObsA.getSubscriptionsCount(), 1);
    assert.equal(kObsB.getSubscriptionsCount(), 0);

    kObsA("AA");
    assertResetSingleCall(spyA, undefined, "AA");
    sinon.assert.notCalled(spyA2);
    kObsB("bb");
    sinon.assert.notCalled(spyB);
    sinon.assert.notCalled(spyB2);
  });

 constructor(){
     this.shouldShowMessage=ko.observable(true);
     this.detail=ko.observable("");
     this.peoples=ko.observableArray([]);
     this.displayMessage=ko.observable(false)
     this.products=ko.observableArray([]);
     this.detailsEnable=ko.observable(false);
 }