chore: cleanup

apps/automated/app/data/observable-array-tests.ts

@@ -0,0 +1,669 @@
+import * as TKUnit from '../tk-unit';
+// >> observable-array-require
+import { Label, ObservableArray, ChangedData, ChangeType } from '@nativescript/core';
+// << observable-array-require
+
+export const test_ObservableArray_shouldCopySourceArrayItems = function () {
+	// >> observable-array-create
+	const sa = [1, 2, 3];
+	const array = new ObservableArray(sa);
+	// << observable-array-create
+
+	TKUnit.assertEqual(array.length, 3, 'ObservableArray length should be 3');
+	TKUnit.assertEqual(sa.length, array.length, 'ObservableArray should copy all source array items!');
+};
+
+export const test_ObservableArray_shouldCopyMultipleItemsAsSource = function () {
+	// // >> observable-array-arguments
+	// const array = new ObservableArray(1, 2, 3);
+	// // << observable-array-arguments
+
+	// TKUnit.assertEqual(array.length, 3, "ObservableArray length should be 3");
+	// TKUnit.assertEqual(array.getItem(1), 2, "ObservableArray should copy multiple items from source!");
+	TKUnit.assertEqual(true, true);
+};
+
+export const test_ObservableArray_shouldCreateArrayFromSpecifiedLength = function () {
+	// >> observable-array-length
+	const array = new ObservableArray(100);
+	// << observable-array-length
+
+	TKUnit.assertEqual(array.length, 100, 'ObservableArray should create array from specified length!');
+};
+
+export const test_ObservableArray_shouldBeAbleToSetLength = function () {
+	// >> observable-array-newvalue
+	const array = new ObservableArray(100);
+	// >> (hide)
+	TKUnit.assertEqual(array.length, 100, 'ObservableArray should create array from specified length!');
+	// << (hide)
+	array.length = 50;
+	// << observable-array-newvalue
+
+	TKUnit.assertEqual(array.length, 50, 'ObservableArray should respect new length!');
+};
+
+export const test_ObservableArray_getItemShouldReturnCorrectItem = function () {
+	// >> observable-array-getitem
+	const array = new ObservableArray([1, 2, 3]);
+	const firstItem = array.getItem(0);
+	const secondItem = array.getItem(1);
+	const thirdItem = array.getItem(2);
+	// << observable-array-getitem
+
+	TKUnit.assert(firstItem === 1 && secondItem === 2 && thirdItem === 3, 'ObservableArray getItem() should return correct item!');
+};
+
+export const test_ObservableArray_setItemShouldSetCorrectItem = function () {
+	// >> observable-array-setitem
+	const array = new ObservableArray([1, 2, 3]);
+	array.setItem(1, 5);
+	// << observable-array-setitem
+	TKUnit.assert(array.getItem(1) === 5, 'ObservableArray setItem() should set correct item!');
+};
+
+export const test_ObservableArray_setItemShouldRaiseCorrectEvent = function () {
+	// >> observable-array-eventdata
+	let index: number;
+	let action: string;
+	let addedCount: number;
+	let removed: Array<number>;
+
+	const array = new ObservableArray([1, 2, 3]);
+	array.on('change', (args) => {
+		index = args.index; // Index of the changed item.
+		action = args.action; // Action. In this case Update.
+		addedCount = args.addedCount; // Number of added items. In this case 1.
+		removed = args.removed; // Array of removed items. In this case with single item (2).
+	});
+	array.setItem(1, 5);
+	// << observable-array-eventdata
+	TKUnit.assertEqual(index, 1);
+	TKUnit.assertEqual(action, ChangeType.Update);
+	TKUnit.assertEqual(addedCount, 1);
+	TKUnit.assertEqual(removed[0], 2);
+};
+
+export const test_ObservableArray_concatShouldReturnNewArrayWithNewItemsAtTheEnd = function () {
+	// >> observable-array-combine
+	const array = new ObservableArray([1, 2, 3]);
+	const result = array.concat([4, 5, 6]);
+	// << observable-array-combine
+	TKUnit.assert(result.length === 6 && result[4] === 5, 'ObservableArray concat() should add items at the end!');
+};
+
+export const test_ObservableArray_joinShouldReturnStringWithAllItemsSeparatedWithComma = function () {
+	// >> observable-array-join
+	const array = new ObservableArray([1, 2, 3]);
+	const result = array.join();
+	// << observable-array-join
+	TKUnit.assert(result === '1,2,3', 'ObservableArray join() should return string with all items separated with comma!');
+};
+
+export const test_ObservableArray_joinShouldReturnStringWithAllItemsSeparatedWithDot = function () {
+	// >> observable-array-join-separator
+	const array = new ObservableArray([1, 2, 3]);
+	const result = array.join('.');
+	// << observable-array-join-separator
+	TKUnit.assert(result === '1.2.3', 'ObservableArray join() should return string with all items separated with dot!');
+};
+
+export const test_ObservableArray_popShouldRemoveTheLastElement = function () {
+	// >> observable-array-join-pop
+	const array = new ObservableArray([1, 2, 3]);
+	// >> (hide)
+	const viewBase = new Label();
+	viewBase.set('testProperty', 0);
+	viewBase.bind({ sourceProperty: 'length', targetProperty: 'testProperty' }, array);
+	// << (hide)
+	const result = array.pop();
+	// << observable-array-join-pop
+	TKUnit.assert(result === 3 && array.length === 2, 'ObservableArray pop() should remove last element!');
+	TKUnit.assert(viewBase.get('testProperty') === array.length, 'Expected: ' + array.length + ', Actual: ' + viewBase.get('testProperty'));
+};
+
+export const test_ObservableArray_popShouldRemoveTheLastElementAndRaiseChangeEventWithCorrectArgs = function () {
+	let result: ChangedData<number>;
+
+	// >> observable-array-join-change
+	const array = new ObservableArray([1, 2, 3]);
+	// >> (hide)
+	const index = array.length - 1;
+	// << (hide)
+
+	array.on(ObservableArray.changeEvent, (args: ChangedData<number>) => {
+		// Argument (args) is ChangedData<T>.
+		// args.eventName is "change".
+		// args.action is "delete".
+		// args.index is equal to the array length - 1.
+		// args.removed.length is 1.
+		// args.addedCount is 0.
+
+		// >> (hide)
+		result = args;
+		// << (hide)
+	});
+
+	array.pop();
+	// << observable-array-join-change
+
+	TKUnit.assert(result.eventName === ObservableArray.changeEvent && result.action === ChangeType.Delete && result.removed.length === 1 && result.index === index && result.addedCount === 0, "ObservableArray pop() should raise 'change' event with correct args!");
+};
+
+export const test_ObservableArray_pushShouldAppendNewElement = function () {
+	// >> observable-array-push
+	const array = new ObservableArray([1, 2, 3]);
+	// >> (hide)
+	const viewBase = new Label();
+	viewBase.set('testProperty', 0);
+	viewBase.bind({ sourceProperty: 'length', targetProperty: 'testProperty' }, array);
+	// << (hide)
+	const result = array.push(4);
+	// << observable-array-push
+	TKUnit.assert(result === 4 && array.getItem(3) === 4, 'ObservableArray push() should append new element!');
+	TKUnit.assert(viewBase.get('testProperty') === array.length, 'Expected: ' + array.length + ', Actual: ' + viewBase.get('testProperty'));
+};
+
+export const test_ObservableArray_pushShouldAppendNewElementAndRaiseChangeEventWithCorrectArgs = function () {
+	let result: ChangedData<number>;
+
+	// >> observable-array-change-push
+	const array = new ObservableArray([1, 2, 3]);
+	array.on(ObservableArray.changeEvent, (args: ChangedData<number>) => {
+		// Argument (args) is ChangedData<T>.
+		// args.eventName is "change".
+		// args.action is "add".
+		// args.index is equal to the array length.
+		// args.removed.length is 0.
+		// args.addedCount is 1.
+
+		// >> (hide)
+		result = args;
+		// << (hide)
+	});
+
+	array.push(4);
+	// << observable-array-change-push
+
+	TKUnit.assert(result.eventName === ObservableArray.changeEvent && result.action === ChangeType.Add && result.removed.length === 0 && result.index === 3 && result.addedCount === 1, "ObservableArray push() should raise 'change' event with correct args!");
+};
+
+export const test_ObservableArray_pushShouldAppendNewElements = function () {
+	// >> observable-array-push-multiple
+	const array = new ObservableArray([1, 2, 3]);
+	// >> (hide)
+	const viewBase = new Label();
+	viewBase.set('testProperty', 0);
+	viewBase.bind({ sourceProperty: 'length', targetProperty: 'testProperty' }, array);
+	// << (hide)
+	const result = array.push(4, 5, 6);
+	// << observable-array-push-multiple
+	TKUnit.assert(result === 6 && array.getItem(5) === 6, 'ObservableArray push() should append new elements!');
+	TKUnit.assert(viewBase.get('testProperty') === array.length, 'Expected: ' + array.length + ', Actual: ' + viewBase.get('testProperty'));
+};
+
+export const test_ObservableArray_pushShouldAppendNewElementsAndRaiseChangeEventWithCorrectArgs = function () {
+	let result: ChangedData<number>;
+
+	// >> observable-array-push-multiple-info
+	const array = new ObservableArray([1, 2, 3]);
+	array.on(ObservableArray.changeEvent, (args: ChangedData<number>) => {
+		// Argument (args) is ChangedData<T>.
+		// args.eventName is "change".
+		// args.action is "add".
+		// args.index is equal to the array length.
+		// args.removed.length is 0.
+		// args.addedCount is equal to the number of added items.
+
+		// >> (hide)
+		result = args;
+		// << (hide)
+	});
+
+	array.push(4, 5, 6);
+	// << observable-array-push-multiple-info
+
+	TKUnit.assert(result.eventName === ObservableArray.changeEvent && result.action === ChangeType.Add && result.removed.length === 0 && result.index === 3 && result.addedCount === 3, "ObservableArray push() should raise 'change' event with correct args!");
+};
+
+export const test_ObservableArray_pushShouldAppendNewElementsFromSourceArray = function () {
+	// >> observable-array-push-source
+	const array = new ObservableArray([1, 2, 3]);
+	// >> (hide)
+	const viewBase = new Label();
+	viewBase.set('testProperty', 0);
+	viewBase.bind({ sourceProperty: 'length', targetProperty: 'testProperty' }, array);
+	// << (hide)
+	const result = array.push([4, 5, 6]);
+	// << observable-array-push-source
+	TKUnit.assert(result === 6 && array.getItem(5) === 6, 'ObservableArray push() should append new elements from source array!');
+	TKUnit.assert(viewBase.get('testProperty') === array.length, 'Expected: ' + array.length + ', Actual: ' + viewBase.get('testProperty'));
+};
+
+export const test_ObservableArray_pushShouldAppendNewElementsFromSourceArrayAndRaiseChangeEventWithCorrectArgs = function () {
+	let result: ChangedData<number>;
+
+	// >> observable-array-push-source-info
+	const array = new ObservableArray([1, 2, 3]);
+	array.on(ObservableArray.changeEvent, (args: ChangedData<number>) => {
+		// Argument (args) is ChangedData<T>.
+		// args.eventName is "change".
+		// args.action is "add".
+		// args.index is equal to the array length.
+		// args.removed.length is 0.
+		// args.addedCount is equal to the number of added items.
+
+		// >> (hide)
+		result = args;
+		// << (hide)
+	});
+
+	array.push([4, 5, 6]);
+	// << observable-array-push-source-info
+
+	TKUnit.assert(result.eventName === ObservableArray.changeEvent && result.action === ChangeType.Add && result.removed.length === 0 && result.index === 3 && result.addedCount === 3, "ObservableArray push() should raise 'change' event with correct args!");
+};
+
+export const test_ObservableArray_reverseShouldReturnNewReversedArray = function () {
+	// >> observable-array-reverse
+	const array = new ObservableArray([1, 2, 3]);
+	const result = array.reverse();
+	// << observable-array-reverse
+	TKUnit.assert(result.length === 3 && result[0] === 3, 'ObservableArray reverse() should return new reversed array!');
+};
+
+export const test_ObservableArray_shiftShouldRemoveTheFirstElement = function () {
+	// >> observable-array-shift
+	const array = new ObservableArray([1, 2, 3]);
+	// >> (hide)
+	const viewBase = new Label();
+	viewBase.set('testProperty', 0);
+	viewBase.bind({ sourceProperty: 'length', targetProperty: 'testProperty' }, array);
+	// << (hide)
+	const result = array.shift();
+	// << observable-array-shift
+	TKUnit.assert(result === 1 && array.length === 2, 'ObservableArray shift() should remove first element!');
+	TKUnit.assert(viewBase.get('testProperty') === array.length, 'Expected: ' + array.length + ', Actual: ' + viewBase.get('testProperty'));
+};
+
+export const test_ObservableArray_shiftShouldRemoveTheFirstElementAndRaiseChangeEventWithCorrectArgs = function () {
+	let result: ChangedData<number>;
+
+	// >> observable-array-shift-change
+	const array = new ObservableArray([1, 2, 3]);
+
+	array.on(ObservableArray.changeEvent, (args: ChangedData<number>) => {
+		// Argument (args) is ChangedData<T>.
+		// args.eventName is "change".
+		// args.action is "delete".
+		// args.index is 0.
+		// args.removed.length is 1.
+		// args.addedCount is 0.
+
+		// >> (hide)
+		result = args;
+		// << (hide)
+	});
+
+	array.shift();
+	// << observable-array-shift-change
+
+	TKUnit.assert(result.eventName === ObservableArray.changeEvent && result.action === ChangeType.Delete && result.removed.length === 1 && result.index === 0 && result.addedCount === 0, "ObservableArray shift() should raise 'change' event with correct args!");
+};
+
+export const test_ObservableArray_sliceShouldReturnSectionAsNewArray = function () {
+	// >> observable-array-slice
+	const array = new ObservableArray([1, 2, 3]);
+	const result = array.slice();
+	// << observable-array-slice
+	TKUnit.assert(result[2] === 3 && result.length === 3, 'ObservableArray slice() should return section!');
+};
+
+export const test_ObservableArray_sliceWithParamsShouldReturnSectionAsNewArray = function () {
+	// >> observable-array-slice-args
+	const array = new ObservableArray([1, 2, 3, 4, 5]);
+	const result = array.slice(2, 4);
+	// << observable-array-slice-args
+	TKUnit.assert(result[1] === 4 && result.length === 2, 'ObservableArray slice() should return section according to specified arguments!');
+};
+
+export const test_ObservableArray_sortShouldReturnNewSortedArray = function () {
+	// >> observable-array-sort
+	const array = new ObservableArray([3, 2, 1]);
+	const result = array.sort();
+	// << observable-array-sort
+	TKUnit.assert(result[0] === 1 && result.length === 3, 'ObservableArray sort() should return new sorted array!');
+};
+
+export const test_ObservableArray_sortShouldReturnNewSortedArrayAccordingSpecifiedOrder = function () {
+	// >> observable-array-sort-comparer
+	const array = new ObservableArray([10, 100, 1]);
+	const result = array.sort((a: number, b: number) => a - b);
+	// << observable-array-sort-comparer
+	TKUnit.assert(result[2] === 100 && result.length === 3, 'ObservableArray sort() should return new sorted array according to specified order!');
+};
+
+export const test_ObservableArray_spliceShouldRemoveSpecifiedNumberOfElementsStartingFromSpecifiedIndex = function () {
+	// >> observable-array-splice
+	const array = new ObservableArray(['one', 'two', 'three']);
+	// >> (hide)
+	const viewBase = new Label();
+	viewBase.set('testProperty', 0);
+	viewBase.bind({ sourceProperty: 'length', targetProperty: 'testProperty' }, array);
+	// << (hide)
+	const result = array.splice(1, 2);
+	// << observable-array-splice
+	TKUnit.assert(result.length === 2 && result[0] === 'two' && array.length === 1 && array.getItem(0) === 'one', 'ObservableArray splice() should remove specified number of elements starting from specified index!');
+	TKUnit.assert(viewBase.get('testProperty') === array.length, 'Expected: ' + array.length + ', Actual: ' + viewBase.get('testProperty'));
+};
+
+export const test_ObservableArray_spliceShouldRemoveSpecifiedNumberOfElementsStartingFromSpecifiedIndexAndRaiseChangeEventWithCorrectArgs = function () {
+	let result: ChangedData<number>;
+
+	// >> observable-array-splice-change
+	const array = new ObservableArray([1, 2, 3]);
+
+	array.on(ObservableArray.changeEvent, (args: ChangedData<number>) => {
+		// Argument (args) is ChangedData<T>.
+		// args.eventName is "change".
+		// args.action is "splice".
+		// args.index is the start index.
+		// args.removed.length is equal to the number of deleted items.
+		// args.addedCount is 0.
+
+		// >> (hide)
+		result = args;
+		// << (hide)
+	});
+
+	array.splice(1, 2);
+	// << observable-array-splice-change
+
+	TKUnit.assert(result.eventName === ObservableArray.changeEvent && result.action === ChangeType.Splice && result.removed.length === 2 && result.index === 1 && result.addedCount === 0, "ObservableArray splice() should raise 'change' event with correct args!");
+};
+
+export const test_ObservableArray_spliceShouldInsertNewItemsInPlaceOfRemovedItemsStartingFromSpecifiedIndex = function () {
+	// >> observable-array-splice-args
+	const array = new ObservableArray(['one', 'two', 'three']);
+	const result = array.splice(1, 2, 'six', 'seven');
+	// << observable-array-splice-args
+	TKUnit.assert(result.length === 2 && result[0] === 'two' && array.length === 3 && array.getItem(2) === 'seven', 'ObservableArray splice() should insert new items in place of removed!');
+};
+
+export const test_ObservableArray_spliceShouldRemoveAndInertSpecifiedNumberOfElementsStartingFromSpecifiedIndexAndRaiseChangeEventWithCorrectArgs = function () {
+	let result: ChangedData<number>;
+
+	// >> observable-array-splice-args-change
+	const array = new ObservableArray(['one', 'two', 'three']);
+
+	array.on(ObservableArray.changeEvent, (args: ChangedData<number>) => {
+		// Argument (args) is ChangedData<T>.
+		// args.eventName is "change".
+		// args.action is "splice".
+		// args.index is the start index.
+		// args.removed.length is equal to the number of deleted items.
+		// args.addedCount is equal to the amount of added and replaced items.
+
+		// >> (hide)
+		result = args;
+		// << (hide)
+	});
+
+	array.splice(1, 2, 'six', 'seven', 'eight');
+	// << observable-array-splice-args-change
+
+	TKUnit.assert(result.eventName === ObservableArray.changeEvent && result.action === ChangeType.Splice && result.removed.length === 2 && result.index === 1 && result.addedCount === 3, "ObservableArray splice() should raise 'change' event with correct args!");
+};
+
+export const test_ObservableArray_unshiftShouldInsertNewElementsFromTheStart = function () {
+	// >> observable-array-unshift
+	const array = new ObservableArray([1, 2, 3]);
+	// >> (hide)
+	const viewBase = new Label();
+	viewBase.set('testProperty', 0);
+	viewBase.bind({ sourceProperty: 'length', targetProperty: 'testProperty' }, array);
+	// << (hide)
+	const result = array.unshift(4, 5);
+	// << observable-array-unshift
+
+	TKUnit.assert(array.getItem(0) === 4 && result === 5 && array.length === 5, 'ObservableArray unshift() should insert new elements from the start!');
+	TKUnit.assert(viewBase.get('testProperty') === array.length, 'Expected: ' + array.length + ', Actual: ' + viewBase.get('testProperty'));
+};
+
+export const test_ObservableArray_unshiftShouldInsertNewElementsFromTheStartAndRaiseChangeEventWithCorrectArgs = function () {
+	let result: ChangedData<number>;
+
+	// >> observable-array-unshift-change
+	const array = new ObservableArray([1, 2, 3]);
+	array.on(ObservableArray.changeEvent, (args: ChangedData<number>) => {
+		//// Argument (args) is ChangedData<T>.
+		//// args.eventName is "change".
+		//// args.action is "add".
+		//// args.index is 0.
+		//// args.removed.length is 0.
+		//// args.addedCount is equal to the number of inserted items.
+
+		// >> (hide)
+		result = args;
+		// << (hide)
+	});
+
+	array.unshift(4, 5);
+	// << observable-array-unshift-change
+
+	TKUnit.assert(result.eventName === ObservableArray.changeEvent && result.action === ChangeType.Add && result.removed.length === 0 && result.index === 0 && result.addedCount === 2, "ObservableArray unshift() should raise 'change' event with correct args!");
+};
+
+export const test_ObservableArray_indexOfShouldReturnCorrectIndex = function () {
+	// >> observable-array-indexof
+	const array = new ObservableArray(['one', 'two', 'three']);
+	const result = array.indexOf('two');
+	// << observable-array-indexof
+	TKUnit.assert(result === 1, 'ObservableArray indexOf() should return correct index!');
+};
+
+export const test_ObservableArray_indexOfShouldReturnCorrectIndexStartingFrom = function () {
+	// >> observable-array-indexof-args
+	const array = new ObservableArray(['one', 'two', 'three']);
+	const result = array.indexOf('two', 2);
+	// << observable-array-indexof-args
+	TKUnit.assert(result === -1, 'ObservableArray indexOf() should return correct index!');
+};
+
+export const test_ObservableArray_lastIndexOfShouldReturnCorrectIndex = function () {
+	const array = new ObservableArray(['one', 'two', 'two', 'three']);
+	// >> observable-array-lastindexof
+	const result = array.lastIndexOf('two');
+	// << observable-array-lastindexof
+	TKUnit.assert(result === 2, 'ObservableArray lastIndexOf() should return correct index!');
+};
+
+export const test_ObservableArray_lastIndexOfShouldReturnCorrectIndexStartingFrom = function () {
+	// >> observable-array-lastindexof-args
+	const array = new ObservableArray(['one', 'two', 'two', 'one', 'three']);
+	const result = array.lastIndexOf('two', 1);
+	// << observable-array-lastindexof-args
+	TKUnit.assert(result === 1, 'ObservableArray lastIndexOf() should return correct index!');
+};
+
+export const test_ObservableArray_settingLengthToZeroPerformsSplice = function () {
+	const array = new ObservableArray([1, 2, 3]);
+
+	let changeRaised = false;
+	array.on('change', (args: ChangedData<number>) => {
+		changeRaised = true;
+		TKUnit.assertEqual(args.object, array);
+		TKUnit.assertEqual(args.eventName, 'change');
+		TKUnit.assertEqual(args.action, ChangeType.Splice);
+		TKUnit.assertEqual(args.index, 0);
+		TKUnit.assertEqual(args.addedCount, 0);
+		TKUnit.arrayAssert(args.removed, [1, 2, 3]);
+	});
+
+	array.length = 0;
+
+	TKUnit.assertEqual(array.length, 0);
+	TKUnit.assertTrue(changeRaised);
+};
+
+export const test_ObservableArray_settingLengthToSomethingPerformsSplice = function () {
+	const array = new ObservableArray([1, 2, 3]);
+	let changeRaised = false;
+
+	array.on('change', (args: ChangedData<number>) => {
+		changeRaised = true;
+		TKUnit.assertEqual(args.object, array);
+		TKUnit.assertEqual(args.eventName, 'change');
+		TKUnit.assertEqual(args.action, ChangeType.Splice);
+		TKUnit.assertEqual(args.index, 1);
+		TKUnit.assertEqual(args.addedCount, 0);
+		TKUnit.arrayAssert(args.removed, [2, 3]);
+	});
+
+	array.length = 1;
+
+	TKUnit.assertEqual(array.length, 1);
+	TKUnit.assertTrue(changeRaised);
+};
+
+const array = new ObservableArray();
+
+// We do not have indexer!
+export const test_getItem_isDefined = function () {
+	TKUnit.assert(typeof array.getItem === 'function', "Method 'getItem()' should be defined!");
+};
+
+export const test_setItem_isDefined = function () {
+	TKUnit.assert(typeof array.setItem === 'function', "Method 'setItem()' should be defined!");
+};
+
+// Standard array properties and methods
+export const test_length_isDefined = function () {
+	TKUnit.assert(typeof array.length === 'number', "Property 'length' should be defined!");
+};
+
+export const test_toString_isDefined = function () {
+	TKUnit.assert(typeof array.toString === 'function', "Method 'toString()' should be defined!");
+};
+
+export const test_toLocaleString_isDefined = function () {
+	TKUnit.assert(typeof array.toLocaleString === 'function', "Method 'toString()' should be defined!");
+};
+
+export const test_concat_isDefined = function () {
+	TKUnit.assert(typeof array.concat === 'function', "Method 'concat()' should be defined!");
+};
+
+export const test_join_isDefined = function () {
+	TKUnit.assert(typeof array.join === 'function', "Method 'join()' should be defined!");
+};
+
+export const test_pop_isDefined = function () {
+	TKUnit.assert(typeof array.pop === 'function', "Method 'pop()' should be defined!");
+};
+
+export const test_push_isDefined = function () {
+	TKUnit.assert(typeof array.push === 'function', "Method 'push()' should be defined!");
+};
+
+export const test_reverse_isDefined = function () {
+	TKUnit.assert(typeof array.reverse === 'function', "Method 'reverse()' should be defined!");
+};
+
+export const test_shift_isDefined = function () {
+	TKUnit.assert(typeof array.shift === 'function', "Method 'shift()' should be defined!");
+};
+
+export const test_slice_isDefined = function () {
+	TKUnit.assert(typeof array.slice === 'function', "Method 'slice()' should be defined!");
+};
+
+export const test_sort_isDefined = function () {
+	TKUnit.assert(typeof array.sort === 'function', "Method 'sort()' should be defined!");
+};
+
+export const test_splice_isDefined = function () {
+	TKUnit.assert(typeof array.splice === 'function', "Method 'splice()' should be defined!");
+};
+
+export const test_unshift_isDefined = function () {
+	TKUnit.assert(typeof array.unshift === 'function', "Method 'unshift()' should be defined!");
+};
+
+export const test_indexOf_isDefined = function () {
+	TKUnit.assert(typeof array.indexOf === 'function', "Method 'indexOf()' should be defined!");
+};
+
+export const test_lastIndexOf_isDefined = function () {
+	TKUnit.assert(typeof array.lastIndexOf === 'function', "Method 'lastIndexOf()' should be defined!");
+};
+
+export const test_every_isDefined = function () {
+	TKUnit.assert(typeof array.every === 'function', "Method 'every()' should be defined!");
+};
+
+export const test_some_isDefined = function () {
+	TKUnit.assert(typeof array.some === 'function', "Method 'some()' should be defined!");
+};
+
+export const test_forEach_isDefined = function () {
+	TKUnit.assert(typeof array.forEach === 'function', "Method 'forEach()' should be defined!");
+};
+
+export const test_map_isDefined = function () {
+	TKUnit.assert(typeof array.map === 'function', "Method 'map()' should be defined!");
+};
+
+export const test_filter_isDefined = function () {
+	TKUnit.assert(typeof array.filter === 'function', "Method 'filter()' should be defined!");
+};
+
+export const test_reduce_isDefined = function () {
+	TKUnit.assert(typeof array.reduce === 'function', "Method 'reduce()' should be defined!");
+};
+
+export const test_reduce_without_initial_value = function () {
+	const sa = [1, 2, 3];
+	let array: ObservableArray<number> = new ObservableArray(sa);
+	const result = array.reduce((a, b) => a + b);
+	TKUnit.assertEqual(result, 6, 'ObservableArray reduce function broken when initialValue is missing');
+};
+
+export const test_reduce_with_initial_value = function () {
+	const sa = [1, 2, 3];
+	let array: ObservableArray<number> = new ObservableArray(sa);
+	const result = array.reduce((a, b) => a + b, 5);
+	TKUnit.assertEqual(result, 11, 'ObservableArray reduce function broken when Initial Value is passed.');
+};
+
+export const test_reduce_with_zero_as_initial_value = function () {
+	const sa = [{ prop: 1 }, { prop: 2 }, { prop: 3 }];
+	let array: ObservableArray<any> = new ObservableArray(sa);
+	const result = array.reduce((a, b) => a + b.prop, 0);
+	TKUnit.assertEqual(result, 6, 'ObservableArray reduce function broken when Initial Value is zero.');
+};
+
+export const test_reduceRight_isDefined = function () {
+	TKUnit.assert(typeof array.reduceRight === 'function', "Method 'reduceRight()' should be defined!");
+};
+
+export const test_reduceRight_without_initial_value = function () {
+	const sa = [1, 2, 3];
+	let array: ObservableArray<number> = new ObservableArray(sa);
+	const result = array.reduceRight((a, b) => a + b);
+	TKUnit.assertEqual(result, 6, 'ObservableArray reduceRight function broken when initialValue is missing');
+};
+
+export const test_reduceRight_with_initial_value = function () {
+	const sa = [1, 2, 3];
+	let array: ObservableArray<number> = new ObservableArray(sa);
+	const result = array.reduceRight((a, b) => a + b, 5);
+	TKUnit.assertEqual(result, 11, 'ObservableArray reduceRight function broken when Initial Value is passed.');
+};
+
+export const test_reduceRight_with_zero_as_initial_value = function () {
+	const sa = [{ prop: 1 }, { prop: 2 }, { prop: 3 }];
+	let array: ObservableArray<any> = new ObservableArray(sa);
+	const result = array.reduceRight((a, b) => a + b.prop, 0);
+	TKUnit.assertEqual(result, 6, 'ObservableArray reduceRight function broken when Initial Value is zero.');
+};

apps/automated/app/data/observable-array.md

@@ -0,0 +1,114 @@
+---
+nav-title: "observable-array How-To"
+title: "observable-array"
+environment: nativescript
+description: "Examples for using observable-array"
+previous_url: /ApiReference/data/observable-array/HOW-TO
+---
+# Observable Array module
+{%snippet observable-array-require%}
+
+### Create ObservableArray from array.
+{%snippet observable-array-create%}
+
+### Create ObservableArray from arguments.
+{%snippet observable-array-arguments%}
+
+### Create ObservableArray with specific length.
+{%snippet observable-array-length%}
+
+### Set ObservableArray length to new value.
+{%snippet observable-array-newvalue%}
+
+### Get item at specified index using getItem(index) method.
+{%snippet observable-array-getitem%}
+
+### Set item at specified index using setItem(index, item) method.
+{%snippet observable-array-setitem%}
+
+### Set item at specified index using setItem(index, item) method and observe change event data.
+{%snippet observable-array-eventdata%}
+
+### Use concat() method to combine ObservableArray with array.
+{%snippet observable-array-combine%}
+
+### Use join() method to convert ObservableArray to comma separated string.
+{%snippet observable-array-join%}
+
+### Use join(separator) method to convert ObservableArray to string separated with specified separator.
+{%snippet observable-array-join-separator%}
+
+### Use pop() method to remove the last element.
+{%snippet observable-array-join-pop%}
+
+### Handle "change" event to know more info about the change after calling pop() method.
+{%snippet observable-array-join-change%}
+
+### Use push() method to add single element to the array.
+{%snippet observable-array-push%}
+
+### Handle "change" event to know more info about the change after calling push() method with single element.
+{%snippet observable-array-change-push%}
+
+### Use push() method to add multiple elements to the array.
+{%snippet observable-array-push-multiple%}
+
+### Handle "change" event to know more info about the change after calling push() method with multiple elements.
+{%snippet observable-array-push-multiple-info%}
+
+### Use push() method to add multiple elements from source array to the ObservableArray.
+{%snippet observable-array-push-source%}
+
+### Handle "change" event to know more info about the change after calling push() method with multiple elements from source array.
+{%snippet observable-array-push-source-info%}
+
+### Use reverse() method to reverse the elements order of the ObservableArray.
+{%snippet observable-array-reverse%}
+
+### Use shift() method to remove the first element of the array.
+{%snippet observable-array-shift%}
+
+### Handle "change" event to know more info about the change after calling shift() method.
+{%snippet observable-array-shift-change%}
+
+### Use slice() method to return array with all ObservableArray elements.
+{%snippet observable-array-slice%}
+
+### Use slice(star, end) method to return section of the array.
+{%snippet observable-array-slice-args%}
+
+### Use sort() method to sort the array.
+{%snippet observable-array-sort%}
+
+### Use sort(compareFunction) method to sort the array with your own comparing logic.
+{%snippet observable-array-sort-comparer%}
+
+### Use splice(start, deleteCount) method to delete elements in the array.
+{%snippet observable-array-splice%}
+
+### Handle "change" event to know more info about the change after calling splice(start, deleteCount) method.
+{%snippet observable-array-splice-change%}
+
+### Use splice(start, deleteCount, ...arguments) method to remove and insert elements in the array.
+{%snippet observable-array-splice-args%}
+
+### Handle "change" event to know more info about the change after calling splice(start, deleteCount, ...arguments) method.
+{%snippet observable-array-splice-args-change%}
+
+### Use unshift(item1, item2... itemN) method to insert elements from the start of the array.
+{%snippet observable-array-unshift%}
+
+### Handle "change" event to know more info about the change after calling unshift(item1, item2... itemN) method.
+{%snippet observable-array-unshift-change%}
+
+### Use indexOf(item) method to get the index of the desired item in the array.
+{%snippet observable-array-indexof%}
+
+### Use indexOf(item, fromIndex) method to get the index of the desired item in the array starting from specified index.
+{%snippet observable-array-indexof-args%}
+
+### Use lastIndexOf(item) method to get the last index of the desired item in the array.
+{%snippet observable-array-lastindexof%}
+
+### Use lastIndexOf(item, fromIndex) method to get the last index of the desired item in the array starting from specified index.
+{%snippet observable-array-lastindexof-args%}

apps/automated/app/data/observable-tests.ts

@@ -0,0 +1,580 @@
+// >> observable-require
+import { Observable, PropertyChangeData, EventData, WrappedValue, fromObject, fromObjectRecursive } from '@nativescript/core';
+// << observable-require
+
+import * as TKUnit from '../tk-unit';
+import * as types from '@nativescript/core/utils/types';
+import { ObservableArray } from '@nativescript/core';
+
+var TESTED_NAME = 'tested';
+class TestObservable extends Observable {
+	public test() {
+		this._emit(TESTED_NAME);
+	}
+}
+
+export var test_Observable_Constructor = function () {
+	// >> observable-creating
+	var json = {
+		Name: 'John',
+		Age: 34,
+		Married: true,
+	};
+	var person = fromObject(json);
+	var name = person.get('Name');
+	var age = person.get('Age');
+	var married = person.get('Married');
+	// console.log(name + " " + age + " " + married); // Prints out "John 34 true" if uncommented.
+	// << observable-creating
+	TKUnit.assert(name === 'John', 'Expected name is John');
+	TKUnit.assert(age === 34, 'Expected age is 34');
+	TKUnit.assert(married === true, 'Expected married is true');
+};
+
+export var tests_DummyTestForCodeSnippet = function () {
+	// >> observable-property-change
+	var person = new Observable();
+	person.set('Name', 'John');
+	person.set('Age', 34);
+	person.set('Married', true);
+	person.addEventListener(Observable.propertyChangeEvent, function (pcd: PropertyChangeData) {
+		//console.log(pcd.eventName.toString() + " " + pcd.propertyName.toString() + " " + pcd.value.toString());
+	});
+	person.set('Age', 35);
+	person.set('Married', false);
+	// If uncommented, the console.log above produces the following output:
+	// propertyChange Age 35
+	// propertyChange Married false
+	// << observable-property-change
+};
+
+export var test_Observable_Members = function () {
+	var obj = new Observable();
+	TKUnit.assert(types.isDefined(obj.addEventListener), 'Observable.addEventListener not defined');
+	TKUnit.assert(types.isDefined(obj._createPropertyChangeData), 'Observable.createPropertyChangeData not defined');
+	TKUnit.assert(types.isDefined(obj._emit), 'Observable.emit not defined');
+	TKUnit.assert(types.isDefined(obj.get), 'Observable.get not defined');
+	TKUnit.assert(types.isDefined(obj.hasListeners), 'Observable.hasListeners not defined');
+	TKUnit.assert(types.isDefined(obj.notify), 'Observable.notify not defined');
+	TKUnit.assert(types.isDefined(obj.off), 'Observable.off not defined');
+	TKUnit.assert(types.isDefined(obj.on), 'Observable.on not defined');
+	TKUnit.assert(types.isDefined(obj.removeEventListener), 'Observable.removeEventListener not defined');
+	TKUnit.assert(types.isDefined(obj.set), 'Observable.set not defined');
+};
+
+export var test_Observable_UpdateAnotherPropertyWithinChangedCallback = function () {
+	var obj = new Observable();
+
+	var changedCallback = function (pcd: PropertyChangeData) {
+		if (pcd.propertyName === 'name') {
+			pcd.object.set('test', 'Changed test');
+		}
+	};
+
+	obj.addEventListener(Observable.propertyChangeEvent, changedCallback);
+
+	obj.set('name', 'Initial name');
+	obj.set('test', 'Initial test');
+
+	TKUnit.assert(obj.get('name') === 'Initial name', 'Initial value for property name is not correct!');
+	TKUnit.assert(obj.get('test') === 'Initial test', 'Initial value for property test is not correct!');
+
+	obj.set('name', 'Changed name');
+
+	TKUnit.assert(obj.get('name') === 'Changed name', 'Changed value for property name is not correct!');
+	TKUnit.assert(obj.get('test') === 'Changed test', 'Changed value for property test is not correct!');
+};
+
+// export var test_DependencyObservable_UpdateAnotherPropertyWithinChangedCallback = function () {
+//     var obj = new dependencyObservable.DependencyObservable();
+
+//     function onFirstPropertyChanged(data: dependencyObservable.PropertyChangeData) {
+//         var testObj = <dependencyObservable.DependencyObservable>data.object;
+//         testObj._setValue(secondProperty, "Changed test");
+//     };
+
+//     var firstProperty = new dependencyObservable.Property(
+//         "first",
+//         "obj",
+//         new proxy.PropertyMetadata(
+//             "",
+//             dependencyObservable.PropertyMetadataSettings.None,
+//             onFirstPropertyChanged
+//         )
+//     );
+
+//     var secondProperty = new dependencyObservable.Property(
+//         "second",
+//         "obj",
+//         new proxy.PropertyMetadata(
+//             "",
+//             dependencyObservable.PropertyMetadataSettings.None,
+//             null
+//         )
+//     );
+
+//     obj._setValue(firstProperty, "Initial name");
+//     obj._setValue(secondProperty, "Initial test");
+
+//     TKUnit.assert(obj._getValue(firstProperty) === "Initial name", "Initial value for property name is not correct!");
+//     TKUnit.assert(obj._getValue(secondProperty) === "Initial test", "Initial value for property test is not correct!");
+
+//     obj._setValue(firstProperty, "Changed name");
+
+//     TKUnit.assert(obj._getValue(firstProperty) === "Changed name", "Changed value for property name is not correct!");
+//     TKUnit.assert(obj._getValue(secondProperty) === "Changed test", "Changed value for property test is not correct!");
+// }
+
+export var test_Observable_addEventListener_SingleEvent = function () {
+	var obj = new Observable();
+
+	var receivedCount = 0;
+	var callback = function (data: PropertyChangeData) {
+		receivedCount++;
+		TKUnit.assert(data.eventName === Observable.propertyChangeEvent, 'Expected event name ' + Observable.propertyChangeEvent);
+		TKUnit.assert(data.object === obj, 'PropertyChangeData.object value not valid.');
+		TKUnit.assert(data.propertyName === 'testName', 'PropertyChangeData.propertyName value not valid.');
+		TKUnit.assert(data.value === 1, 'PropertyChangeData.value value not valid.');
+	};
+
+	obj.addEventListener(Observable.propertyChangeEvent, callback);
+	obj.set('testName', 1);
+	TKUnit.assert(receivedCount === 1, 'PropertyChanged event not raised properly.');
+};
+
+export var test_Observable_addEventListener_MultipleEvents = function () {
+	var obj = new TestObservable();
+
+	var receivedCount = 0;
+	var callback = function (data: EventData) {
+		receivedCount++;
+		TKUnit.assert(data.object === obj, 'EventData.object value not valid.');
+
+		if (data.eventName === Observable.propertyChangeEvent) {
+			var propertyData = <PropertyChangeData>data;
+			TKUnit.assert(propertyData.eventName === Observable.propertyChangeEvent, 'Expected event name ' + Observable.propertyChangeEvent);
+			TKUnit.assert(propertyData.propertyName === 'testName', 'PropertyChangeData.propertyName value not valid.');
+			TKUnit.assert(propertyData.value === 1, 'PropertyChangeData.value value not valid.');
+		} else {
+			TKUnit.assert(data.eventName === TESTED_NAME, 'Expected event name ' + TESTED_NAME);
+		}
+	};
+
+	var events = Observable.propertyChangeEvent + ',' + TESTED_NAME;
+	obj.addEventListener(events, callback);
+	obj.set('testName', 1);
+	obj.test();
+	TKUnit.assert(receivedCount === 2, 'Callbacks not raised properly.');
+};
+
+export var test_Observable_addEventListener_MultipleEvents_ShouldTrim = function () {
+	var obj = new TestObservable();
+
+	var receivedCount = 0;
+	var callback = function (data: EventData) {
+		receivedCount++;
+	};
+
+	var events = Observable.propertyChangeEvent + '  ,  ' + TESTED_NAME;
+	obj.addEventListener(events, callback);
+	TKUnit.assert(obj.hasListeners(Observable.propertyChangeEvent), 'Observable.addEventListener for multiple events should trim each event name.');
+	TKUnit.assert(obj.hasListeners(TESTED_NAME), 'Observable.addEventListener for multiple events should trim each event name.');
+
+	obj.set('testName', 1);
+	obj.test();
+
+	TKUnit.assert(receivedCount === 2, 'Callbacks not raised properly.');
+};
+
+export var test_Observable_addEventListener_MultipleCallbacks = function () {
+	var obj = new TestObservable();
+
+	var receivedCount = 0;
+	var callback1 = function (data: EventData) {
+		receivedCount++;
+	};
+
+	var callback2 = function (data: EventData) {
+		receivedCount++;
+	};
+
+	obj.addEventListener(Observable.propertyChangeEvent, callback1);
+	obj.addEventListener(Observable.propertyChangeEvent, callback2);
+
+	obj.set('testName', 1);
+	TKUnit.assert(receivedCount === 2, 'The propertyChanged notification should be raised twice.');
+};
+
+export var test_Observable_addEventListener_MultipleCallbacks_MultipleEvents = function () {
+	var obj = new TestObservable();
+
+	var receivedCount = 0;
+	var callback1 = function (data: EventData) {
+		receivedCount++;
+	};
+
+	var callback2 = function (data: EventData) {
+		receivedCount++;
+	};
+
+	var events = Observable.propertyChangeEvent + '  ,  ' + TESTED_NAME;
+	obj.addEventListener(events, callback1);
+	obj.addEventListener(events, callback2);
+
+	obj.set('testName', 1);
+	obj.test();
+
+	TKUnit.assert(receivedCount === 4, 'The propertyChanged notification should be raised twice.');
+};
+
+export var test_Observable_removeEventListener_SingleEvent_SingleCallback = function () {
+	var obj = new Observable();
+
+	var receivedCount = 0;
+	var callback = function (data: EventData) {
+		receivedCount++;
+	};
+
+	obj.addEventListener(Observable.propertyChangeEvent, callback);
+	obj.set('testName', 1);
+
+	obj.removeEventListener(Observable.propertyChangeEvent, callback);
+	TKUnit.assert(!obj.hasListeners(Observable.propertyChangeEvent), 'Observable.removeEventListener not working properly.');
+
+	obj.set('testName', 2);
+	TKUnit.assert(receivedCount === 1, 'Observable.removeEventListener not working properly.');
+};
+
+export var test_Observable_removeEventListener_SingleEvent_MultipleCallbacks = function () {
+	var obj = new Observable();
+
+	var receivedCount = 0;
+	var callback1 = function (data: EventData) {
+		receivedCount++;
+	};
+
+	var callback2 = function (data: EventData) {
+		receivedCount++;
+	};
+
+	obj.addEventListener(Observable.propertyChangeEvent, callback1);
+	obj.addEventListener(Observable.propertyChangeEvent, callback2);
+	obj.set('testName', 1);
+
+	obj.removeEventListener(Observable.propertyChangeEvent, callback1);
+	TKUnit.assert(obj.hasListeners(Observable.propertyChangeEvent), 'Observable.removeEventListener not working properly with multiple listeners.');
+
+	obj.set('testName', 2);
+	TKUnit.assert(receivedCount === 3, 'Observable.removeEventListener not working properly with multiple listeners.');
+
+	obj.removeEventListener(Observable.propertyChangeEvent, callback2);
+	TKUnit.assert(!obj.hasListeners(Observable.propertyChangeEvent), 'Observable.removeEventListener not working properly with multiple listeners.');
+
+	obj.set('testName', 3);
+	TKUnit.assert(receivedCount === 3, 'Observable.removeEventListener not working properly with multiple listeners.');
+};
+
+export var test_Observable_removeEventListener_MutlipleEvents_SingleCallback = function () {
+	var obj = new TestObservable();
+
+	var receivedCount = 0;
+	var callback = function (data: EventData) {
+		receivedCount++;
+	};
+
+	var events = Observable.propertyChangeEvent + '  ,  ' + TESTED_NAME;
+	obj.addEventListener(events, callback);
+
+	obj.set('testName', 1);
+	obj.test();
+
+	obj.removeEventListener(events, callback);
+
+	TKUnit.assert(!obj.hasListeners(Observable.propertyChangeEvent), 'Expected result for hasObservers is false');
+	TKUnit.assert(!obj.hasListeners(TESTED_NAME), 'Expected result for hasObservers is false.');
+
+	obj.set('testName', 2);
+	obj.test();
+
+	TKUnit.assert(receivedCount === 2, 'Expected receive count is 2');
+};
+
+export var test_Observable_removeEventListener_SingleEvent_NoCallbackSpecified = function () {
+	var obj = new TestObservable();
+
+	var receivedCount = 0;
+	var callback1 = function (data: EventData) {
+		receivedCount++;
+	};
+
+	var callback2 = function (data: EventData) {
+		receivedCount++;
+	};
+
+	obj.addEventListener(Observable.propertyChangeEvent, callback1);
+	obj.addEventListener(Observable.propertyChangeEvent, callback2);
+
+	obj.set('testName', 1);
+	obj.removeEventListener(Observable.propertyChangeEvent);
+
+	TKUnit.assert(!obj.hasListeners(Observable.propertyChangeEvent), 'Expected result for hasObservers is false.');
+
+	obj.set('testName', 2);
+	TKUnit.assert(receivedCount === 2, 'Expected receive count is 2');
+};
+
+export var test_Observable_WhenCreatedWithJSON_PropertyChangedWithDotNotation_RaisesPropertyChangedEvent = function () {
+	var json = {
+		count: 5,
+	};
+	var obj = fromObject(json);
+
+	var receivedCount = 0;
+	var callback = function (data: PropertyChangeData) {
+		receivedCount++;
+		TKUnit.assert(data.eventName === Observable.propertyChangeEvent, 'Expected event name ' + Observable.propertyChangeEvent);
+		TKUnit.assert(data.object === obj, 'PropertyChangeData.object value not valid.');
+		TKUnit.assert(data.propertyName === 'count', 'PropertyChangeData.propertyName value not valid.');
+		TKUnit.assert(data.value === 6, 'PropertyChangeData.value value not valid.');
+	};
+
+	obj.addEventListener(Observable.propertyChangeEvent, callback);
+
+	(<any>obj).count++;
+
+	TKUnit.assert(receivedCount === 1, 'PropertyChanged event not raised properly.');
+};
+
+export var test_Observable_WhenCreatedWithJSON_PropertyChangedWithBracketsNotation_RaisesPropertyChangedEvent = function () {
+	var json = {
+		count: 5,
+	};
+	var obj = fromObject(json);
+
+	var receivedCount = 0;
+	var callback = function (data: PropertyChangeData) {
+		receivedCount++;
+		TKUnit.assert(data.eventName === Observable.propertyChangeEvent, 'Expected event name ' + Observable.propertyChangeEvent);
+		TKUnit.assert(data.object === obj, 'PropertyChangeData.object value not valid.');
+		TKUnit.assert(data.propertyName === 'count', 'PropertyChangeData.propertyName value not valid.');
+		TKUnit.assert(data.value === 6, 'PropertyChangeData.value value not valid.');
+	};
+
+	obj.addEventListener(Observable.propertyChangeEvent, callback);
+
+	obj['count']++;
+
+	TKUnit.assert(receivedCount === 1, 'PropertyChanged event not raised properly.');
+};
+
+export var test_AddingTwoEventHandlersAndRemovingWithinHandlerShouldRaiseAllEvents = function () {
+	var observableInstance = new Observable();
+	var firstHandlerCalled = false;
+	var secondHandlerCalled = false;
+
+	var firstHandler = function (args) {
+		observableInstance.off(Observable.propertyChangeEvent, firstHandler, firstObserver);
+		firstHandlerCalled = true;
+	};
+
+	var secondHandler = function (args) {
+		observableInstance.off(Observable.propertyChangeEvent, secondHandler, secondObserver);
+		secondHandlerCalled = true;
+	};
+
+	var firstObserver = new Observable();
+	var secondObserver = new Observable();
+
+	observableInstance.on(Observable.propertyChangeEvent, firstHandler, firstObserver);
+	observableInstance.on(Observable.propertyChangeEvent, secondHandler, secondObserver);
+
+	observableInstance.set('someProperty', 'some value');
+
+	TKUnit.assertEqual(firstHandlerCalled, true);
+	TKUnit.assertEqual(secondHandlerCalled, true);
+};
+
+export var test_ObservableCreatedWithJSON_shouldDistinguishSeparateObjects = function () {
+	var obj1 = { val: 1 };
+	var obj2 = { val: 2 };
+	var observable1 = fromObject(obj1);
+	var observable2 = fromObject(obj2);
+
+	var val1 = observable1.get('val');
+	var val2 = observable2.get('val');
+	TKUnit.assert(val1 === 1 && val2 === 2, `Observable should keep separate objects separate! val1: ${val1}; val2: ${val2};`);
+
+	var propName1;
+	var newValue1;
+	observable1.on(Observable.propertyChangeEvent, (data: PropertyChangeData) => {
+		propName1 = data.propertyName;
+		newValue1 = data.value;
+	});
+
+	var propName2;
+	var newValue2;
+	observable2.on(Observable.propertyChangeEvent, (data: PropertyChangeData) => {
+		propName2 = data.propertyName;
+		newValue2 = data.value;
+	});
+
+	observable1.set('val', 10);
+	TKUnit.assert(propName1 === 'val', "propName1 should be 'val'");
+	TKUnit.assert(newValue1 === 10, 'newValue1 should be 10');
+
+	observable2.set('val', 20);
+	TKUnit.assert(propName2 === 'val', "propName2 should be 'val'");
+	TKUnit.assert(newValue2 === 20, 'newValue2 should be 20');
+
+	val1 = observable1.get('val');
+	val2 = observable2.get('val');
+	TKUnit.assert(val1 === 10 && val2 === 20, `Observable should keep separate objects separate! val1: ${val1}; val2: ${val2};`);
+};
+
+export var test_ObservablesCreatedWithJSON_shouldNotInterfereWithOneAnother = function () {
+	var observable1 = fromObject({ property1: 1 });
+	var observable2 = fromObject({ property2: 2 });
+
+	TKUnit.assert(observable1.get('property1') === 1, `Expected: 1; Actual: ${observable1.get('property1')}`);
+	TKUnit.assert(observable1.get('property2') === undefined, `Expected: undefined; Actual: ${observable1.get('property2')}`);
+
+	TKUnit.assert(observable2.get('property1') === undefined, `Expected: undefined; Actual: ${observable2.get('property1')}`);
+	TKUnit.assert(observable2.get('property2') === 2, `Expected: 2; Actual: ${observable2.get('property2')}`);
+
+	var propName1;
+	var newValue1;
+	observable1.on(Observable.propertyChangeEvent, (data: PropertyChangeData) => {
+		propName1 = data.propertyName;
+		newValue1 = data.value;
+	});
+
+	var propName2;
+	var newValue2;
+	observable2.on(Observable.propertyChangeEvent, (data: PropertyChangeData) => {
+		propName2 = data.propertyName;
+		newValue2 = data.value;
+	});
+
+	observable1.set('property1', 10);
+	TKUnit.assert(propName1 === 'property1', "propName1 should be 'property1'");
+	TKUnit.assert(newValue1 === 10, 'newValue1 should be 10');
+
+	observable2.set('property2', 20);
+	TKUnit.assert(propName2 === 'property2', "propName2 should be 'property2'");
+	TKUnit.assert(newValue2 === 20, 'newValue2 should be 20');
+};
+
+export function test_ObservablesCreatedWithJSON_shouldNotEmitTwoTimesPropertyChangeEvent() {
+	var testObservable = fromObject({ property1: 1 });
+	var propertyChangeCounter = 0;
+	var propertyChangeHandler = function (args) {
+		propertyChangeCounter++;
+	};
+	testObservable.on(Observable.propertyChangeEvent, propertyChangeHandler);
+	testObservable.set('property1', 2);
+
+	TKUnit.assertEqual(propertyChangeCounter, 1, 'PropertyChange event should be fired only once for a single change.');
+}
+
+export function test_ObservableShouldEmitPropertyChangeWithSameObjectUsingWrappedValue() {
+	var testArray = [1];
+	var testObservable = fromObject({ property1: testArray });
+	var propertyChangeCounter = 0;
+	var propertyChangeHandler = function (args) {
+		propertyChangeCounter++;
+	};
+	testObservable.on(Observable.propertyChangeEvent, propertyChangeHandler);
+	testArray.push(2);
+
+	testObservable.set('property1', testArray);
+
+	TKUnit.assertEqual(propertyChangeCounter, 0, 'PropertyChange event should not be fired when the same object instance is passed.');
+
+	testObservable.set('property1', WrappedValue.wrap(testArray));
+
+	TKUnit.assertEqual(propertyChangeCounter, 1, 'PropertyChange event should be fired only once for a single change.');
+}
+
+export function test_CorrectEventArgsWhenWrappedValueIsUsed() {
+	let testArray = [1];
+	let testObservable = fromObject({ property1: testArray });
+	let actualArgsValue;
+	let propertyChangeHandler = function (args) {
+		actualArgsValue = args.value;
+	};
+
+	testObservable.on(Observable.propertyChangeEvent, propertyChangeHandler);
+	testArray.push(2);
+
+	let wrappedArray = WrappedValue.wrap(testArray);
+
+	testObservable.set('property1', wrappedArray);
+
+	TKUnit.assertEqual(actualArgsValue, testArray, 'PropertyChange event should be fired with correct value in arguments.');
+}
+
+export function test_CorrectPropertyValueAfterUsingWrappedValue() {
+	let testArray = [1];
+	let testObservable = fromObject({ property1: testArray });
+
+	let wrappedArray = WrappedValue.wrap(testArray);
+
+	testObservable.set('property1', wrappedArray);
+
+	TKUnit.assertEqual(testObservable.get('property1'), testArray, 'WrappedValue is used only to execute property change logic and unwrapped value should be used as property value.');
+}
+
+export function test_CorrectPropertyValueAfterUsingStringEmptyWrappedValue() {
+	const emptyString = '';
+	let testObservable = fromObject({ property1: emptyString });
+
+	let wrappedEmptyString = WrappedValue.wrap(emptyString);
+
+	testObservable.set('property1', wrappedEmptyString);
+
+	TKUnit.assertEqual(testObservable.get('property1'), emptyString, 'WrappedValue is used only to execute property change logic and unwrapped value should be used as property value.');
+}
+
+export function test_NestedObservablesWithObservableArrayShouldNotCrash() {
+	let someObservableArray = new ObservableArray<any>();
+	let testObservable = fromObjectRecursive({
+		firstProp: 'test string',
+		secondProp: someObservableArray,
+	});
+	TKUnit.assert(testObservable !== undefined);
+}
+
+export function test_NestedObservableWithNullShouldNotCrash() {
+	let testObservable = fromObjectRecursive({
+		someProperty: null,
+	});
+	TKUnit.assert(testObservable !== undefined);
+}
+
+export function test_get_set_on_observables_fromObject_without_property_in_json() {
+	const array = new ObservableArray<any>();
+	const vm = fromObject({});
+	vm.set('p', array);
+	const value1 = vm.get('p');
+	const value2 = (<any>vm).p;
+	TKUnit.assertEqual(value1, array);
+	TKUnit.assertNull(value2);
+}
+
+export function test_get_set_on_observables_fromObject_with_property_in_json() {
+	const array = new ObservableArray<any>();
+	const vm = fromObject({ p: null });
+	vm.set('p', array);
+	const value1 = vm.get('p');
+	const value2 = (<any>vm).p;
+	TKUnit.assertEqual(value1, array);
+	TKUnit.assertEqual(value2, array);
+}
+
+export function test_fromObjectRecursive_does_not_override_source_object_property() {
+	const myObj = {};
+	const source = { name: 'a', value: myObj };
+	const observable = fromObjectRecursive(source);
+	TKUnit.assertNotNull(observable);
+	TKUnit.assertEqual(source.value, myObj);
+}

apps/automated/app/data/observable.md

@@ -0,0 +1,16 @@
+---
+nav-title: "data/observable How-To"
+title: "observable"
+environment: nativescript
+description: "Examples for using data/observable"
+previous_url: /ApiReference/data/observable/HOW-TO
+---
+# Observable
+Using Observable objects requires the "data/observable" module.
+{%snippet observable-require%}
+
+### Creating an Observable
+{%snippet observable-creating%}
+
+### Responding to property changes
+{%snippet observable-property-change%}

apps/automated/app/data/virtual-array-tests.ts

@@ -0,0 +1,172 @@
+import * as TKUnit from '../tk-unit';
+import * as types from '@nativescript/core/utils/types';
+import { VirtualArray, ChangeType, ChangedData, ItemsLoading } from '@nativescript/core';
+
+export var test_VirtualArray_shouldCreateArrayFromSpecifiedLength = function () {
+	var array = new VirtualArray<number>(100);
+
+	TKUnit.assert(array.length === 100, 'VirtualArray<T> should create array from specified length!');
+};
+
+export var test_VirtualArray_setItemShouldSetCorrectItem = function () {
+	var array = new VirtualArray<number>(100);
+	array.setItem(0, 0);
+	TKUnit.assert(array.getItem(0) === 0, 'VirtualArray<T> setItem() should set correct item!');
+};
+
+export var test_VirtualArray_setItemShouldRaiseChangeEventWhenYouSetDifferentItem = function () {
+	var array = new VirtualArray<number>(100);
+	array.loadSize = 15;
+
+	var result: ChangedData<number>;
+	var index = 0;
+
+	array.on(VirtualArray.changeEvent, (args: ChangedData<number>) => {
+		result = args;
+	});
+
+	array.setItem(index, 0);
+
+	TKUnit.assert(result && result.eventName === 'change' && result.action === ChangeType.Update && result.removed.length === 1 && result.index === index && result.addedCount === 1, "VirtualArray<T> setItem() should raise 'change' event with correct args!");
+
+	result = undefined;
+
+	array.setItem(index, 1);
+
+	TKUnit.assert(result && result.eventName === 'change' && result.action === ChangeType.Update && result.removed.length === 1 && result.index === index && result.addedCount === 1, "VirtualArray<T> setItem() should raise 'change' event with correct args!");
+
+	array.on(VirtualArray.itemsLoadingEvent, (args: ItemsLoading) => {
+		// Argument (args) is ItemsLoading.
+		// args.index is start index of the page where the requested index is located.
+		// args.count number of requested items.
+		//
+		// Note: Virtual array will divide total number of items to pages using "loadSize" property value. When you request an
+		// item at specific index the array will raise "itemsLoading" event with "ItemsLoading" argument index set to the first index of the requested page
+		// and count set to number of items in this page.
+		//
+		// Important: If you have already loaded items in the requested page the array will raise multiple times "itemsLoading" event to request
+		// all ranges of still not loaded items in this page.
+
+		var itemsToLoad = new Array<number>();
+		for (var i = 0; i < args.count; i++) {
+			itemsToLoad.push(i + args.index);
+		}
+
+		array.load(args.index, itemsToLoad);
+	});
+};
+
+export var test_VirtualArray_loadShouldRaiseChangeEventWithCorrectArgs = function () {
+	var array = new VirtualArray<number>(100);
+	array.loadSize = 15;
+
+	var result: ChangedData<number>;
+	var index = 0;
+
+	array.on(VirtualArray.changeEvent, (args: ChangedData<number>) => {
+		// Argument (args) is ChangedData<T>.
+		// args.eventName is "change".
+		// args.action is "update".
+		// args.removed.length and result.addedCount are equal to number of loaded items with load() method.
+
+		result = args;
+	});
+
+	var itemsToLoad = [0, 1, 2];
+
+	array.load(index, itemsToLoad);
+
+	TKUnit.assert(result && result.eventName === 'change' && result.action === ChangeType.Update && result.removed.length === itemsToLoad.length && result.index === index && result.addedCount === itemsToLoad.length, "VirtualArray<T> load() should raise 'change' event with correct args!");
+};
+
+export var test_VirtualArray_lengthIncreaseShouldRaiseChangeEventWithCorrectArgs = function () {
+	var array = new VirtualArray<number>(100);
+	array.loadSize = 15;
+
+	var result: ChangedData<number>;
+	var index = array.length;
+
+	array.on(VirtualArray.changeEvent, (args: ChangedData<number>) => {
+		// Argument (args) is ChangedData<T>.
+		// args.eventName is "change".
+		// args.action is "add".
+		// args.removed.length is 0, result.addedCount is equal to the delta between new and old "length" property values.
+
+		result = args;
+	});
+
+	array.length += array.loadSize;
+
+	TKUnit.assert(result && result.eventName === 'change' && result.action === ChangeType.Add && result.index === index && result.addedCount === array.loadSize && result.removed.length === 0, "VirtualArray<T> length++ should raise 'change' event with correct args!");
+};
+
+export var test_VirtualArray_lengthDecreaseShouldRaiseChangeEventWithCorrectArgs = function () {
+	var array = new VirtualArray<number>(100);
+	array.loadSize = 15;
+
+	var result: ChangedData<number>;
+	var index = array.length;
+
+	array.on(VirtualArray.changeEvent, (args: ChangedData<number>) => {
+		// Argument (args) is ChangedData<T>.
+		// args.eventName is "change".
+		// args.action is "remove".
+		// result.addedCount is 0, args.removed.length is equal to the delta between new and old "length" property values.
+
+		result = args;
+	});
+
+	array.length -= array.loadSize;
+
+	TKUnit.assert(result && result.eventName === 'change' && result.action === ChangeType.Delete && result.index === index && result.removed.length === array.loadSize && result.addedCount === 0, "VirtualArray<T> length++ should raise 'change' event with correct args!");
+};
+
+export var test_VirtualArray_shouldRaiseItemsLoadingIfIndexIsNotLoadedAndGetItemIsCalled = function () {
+	var array = new VirtualArray<number>(100);
+	array.loadSize = 15;
+
+	var result: ItemsLoading;
+
+	array.on(VirtualArray.itemsLoadingEvent, (args: ItemsLoading) => {
+		result = args;
+	});
+
+	array.getItem(0);
+
+	TKUnit.assert(result.eventName === VirtualArray.itemsLoadingEvent && result.index === 0 && result.count === array.loadSize, "VirtualArray<T> getItem() should raise 'itemsLoading' event with correct args if item is not loaded!");
+};
+
+export var test_VirtualArray_shouldNotRaiseItemsLoadingIfIndexIsLoadedAndGetItemIsCalled = function () {
+	var array = new VirtualArray<number>(100);
+	array.setItem(0, 0);
+	array.loadSize = 15;
+
+	var result: ItemsLoading;
+
+	array.on(VirtualArray.itemsLoadingEvent, (args: ItemsLoading) => {
+		result = args;
+	});
+
+	array.getItem(0);
+
+	TKUnit.assert(types.isUndefined(result), "VirtualArray<T> getItem() should not raise 'itemsLoading' event if item is loaded!");
+};
+
+export var test_VirtualArray_shouldRaiseItemsLoadingIfIndexIsNotLoadedAndGetItemIsCalledCorrectNumberOfTimesWithCorrectArgs = function () {
+	var array = new VirtualArray<number>(100);
+	array.loadSize = 15;
+
+	array.setItem(0, 0);
+
+	array.setItem(5, 5);
+
+	var result = new Array<ItemsLoading>();
+
+	array.on(VirtualArray.itemsLoadingEvent, (args: ItemsLoading) => {
+		result.push(args);
+	});
+
+	array.getItem(1);
+
+	TKUnit.assert(result.length === 2 && result[0].eventName === VirtualArray.itemsLoadingEvent && result[0].index === 1 && result[0].count === 4 && result[1].eventName === VirtualArray.itemsLoadingEvent && result[1].index === 6 && result[1].count === 9, "VirtualArray<T> getItem() should raise 'itemsLoading' event with correct args!");
+};

apps/automated/app/data/virtual-array.md

@@ -0,0 +1,24 @@
+---
+nav-title: "virtual-array How-To"
+title: "virtual-array"
+environment: nativescript
+description: "Examples for using virtual-array"
+previous_url: /ApiReference/data/virtual-array/HOW-TO
+---
+# Virtual Array module
+{%snippet virtual-array-require%}
+
+### Handle "itemsLoading" event to load items on demand using load() method.
+Use "length" property set via VirtualArray constructor to specify total number of items,
+"loadSize" to specify number of items to be requested in a single request,
+"itemsLoading" event to handle items request and "load()" method to copy items into the array.
+All already loaded items are cached in -memory and when "getItem()" method is called
+the array will raise "itemsLoading" event for still not loaded items.
+{%snippet virtual-array-itemsloading%}
+
+### Handle "change" event when you load items using load() method.
+{%snippet virtual-array-change%}
+
+### Handle "change" event when you increase "length" property.
+{%snippet virtual-array-lenght%}
+