tests/tests.js - cordova-plugin-device-motion - Git at Google

 /*
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
  */

 /* global cordova, Windows */

 exports.defineAutoTests = function () {
     var isWindows = cordova.platformId === 'windows';
     // Checking existence of accelerometer for windows platform
     // Assumed that accelerometer always exists on other platforms. Extend
     // condition to support accelerometer check on other platforms
     var isAccelExist = isWindows ? Windows.Devices.Sensors.Accelerometer.getDefault() !== null : true;

     describe('Accelerometer (navigator.accelerometer)', function () {
         var fail = function (done) {
             expect(true).toBe(false);
             done();
         };

         // This timeout is here to lessen the load on native accelerometer
         // intensive use of which can lead to occasional test failures
         afterEach(function (done) {
             setTimeout(function () {
                 done();
             }, 100);
         });

         it('accelerometer.spec.1 should exist', function () {
             expect(navigator.accelerometer).toBeDefined();
         });

         describe('getCurrentAcceleration', function () {
             it('accelerometer.spec.2 should exist', function () {
                 expect(typeof navigator.accelerometer.getCurrentAcceleration).toBeDefined();
                 expect(typeof navigator.accelerometer.getCurrentAcceleration === 'function').toBe(true);
             });

             it('accelerometer.spec.3 success callback should be called with an Acceleration object', function (done) {
                 // skip the test if Accelerometer doesn't exist on this device
                 if (!isAccelExist) {
                     pending();
                 }
                 var win = function (a) {
                     expect(a).toBeDefined();
                     expect(a.x).toBeDefined();
                     expect(typeof a.x === 'number').toBe(true);
                     expect(a.y).toBeDefined();
                     expect(typeof a.y === 'number').toBe(true);
                     expect(a.z).toBeDefined();
                     expect(typeof a.z === 'number').toBe(true);
                     expect(a.timestamp).toBeDefined();
                     expect(typeof a.timestamp).toBe('number');
                     done();
                 };

                 var onError = function (err) {
                     console.log(err);
                     console.log('Skipping gyroscope tests, marking all as pending.');
                     isAccelExist = false;
                     expect(true).toBe(true);
                     done();
                 };

                 navigator.accelerometer.getCurrentAcceleration(win, onError);
             });

             it('accelerometer.spec.4 success callback Acceleration object should have (reasonable) values for x, y and z expressed in m/s^2', function (done) {
                 // skip the test if Accelerometer doesn't exist on this device
                 if (!isAccelExist) {
                     pending();
                 }
                 var reasonableThreshold = 15;
                 var win = function (a) {
                     expect(a.x).toBeLessThan(reasonableThreshold);
                     expect(a.x).toBeGreaterThan(reasonableThreshold * -1);
                     expect(a.y).toBeLessThan(reasonableThreshold);
                     expect(a.y).toBeGreaterThan(reasonableThreshold * -1);
                     expect(a.z).toBeLessThan(reasonableThreshold);
                     expect(a.z).toBeGreaterThan(reasonableThreshold * -1);
                     done();
                 };

                 navigator.accelerometer.getCurrentAcceleration(win, fail.bind(null, done));
             });

             it('accelerometer.spec.5 success callback Acceleration object should return a recent timestamp', function (done) {
                 // skip the test if Accelerometer doesn't exist on this device
                 if (!isAccelExist) {
                     pending();
                 }
                 var veryRecently = new Date().getTime();
                 // Need to check that dates returned are not vastly greater than a recent time stamp.
                 // In case the timestamps returned are ridiculously high
                 var reasonableTimeLimit = veryRecently + 5000; // 5 seconds from now
                 var win = function (a) {
                     expect(a.timestamp).toBeGreaterThan(veryRecently - 200); // this is flakey, relaxing a bit
                     expect(a.timestamp).toBeLessThan(reasonableTimeLimit);
                     done();
                 };

                 navigator.accelerometer.getCurrentAcceleration(win, fail.bind(null, done));
             });
         });

         describe('watchAcceleration', function () {
             var id;

             afterEach(function (done) {
                 if (id) {
                     navigator.accelerometer.clearWatch(id);
                 }
                 // clearWatch implementation is async but doesn't accept a cllback
                 // so let's give it some time before starting next spec
                 setTimeout(done, 100);
             });

             it('accelerometer.spec.6 should exist', function () {
                 expect(navigator.accelerometer.watchAcceleration).toBeDefined();
                 expect(typeof navigator.accelerometer.watchAcceleration === 'function').toBe(true);
             });

             it('accelerometer.spec.7 success callback should be called with an Acceleration object', function (done) {
                 // skip the test if Accelerometer doesn't exist on this device
                 if (!isAccelExist) {
                     pending();
                 }
                 var win = function (a) {
                     expect(a).toBeDefined();
                     expect(a.x).toBeDefined();
                     expect(typeof a.x === 'number').toBe(true);
                     expect(a.y).toBeDefined();
                     expect(typeof a.y === 'number').toBe(true);
                     expect(a.z).toBeDefined();
                     expect(typeof a.z === 'number').toBe(true);
                     expect(a.timestamp).toBeDefined();
                     expect(typeof a.timestamp).toBe('number');
                     done();
                 };

                 id = navigator.accelerometer.watchAcceleration(win, fail.bind(null, done), { frequency: 100 });
             });

             it('accelerometer.spec.8 success callback Acceleration object should have (reasonable) values for x, y and z expressed in m/s^2', function (done) {
                 // skip the test if Accelerometer doesn't exist on this device
                 if (!isAccelExist) {
                     pending();
                 }
                 var reasonableThreshold = 15;
                 var win = function (a) {
                     expect(a.x).toBeLessThan(reasonableThreshold);
                     expect(a.x).toBeGreaterThan(reasonableThreshold * -1);
                     expect(a.y).toBeLessThan(reasonableThreshold);
                     expect(a.y).toBeGreaterThan(reasonableThreshold * -1);
                     expect(a.z).toBeLessThan(reasonableThreshold);
                     expect(a.z).toBeGreaterThan(reasonableThreshold * -1);
                     done();
                 };

                 id = navigator.accelerometer.watchAcceleration(win, fail.bind(null, done), { frequency: 100 });
             });

             it('accelerometer.spec.9 success callback Acceleration object should return a recent timestamp', function (done) {
                 // skip the test if Accelerometer doesn't exist on this device
                 if (!isAccelExist) {
                     pending();
                 }
                 var veryRecently = new Date().getTime();
                 // Need to check that dates returned are not vastly greater than a recent time stamp.
                 // In case the timestamps returned are ridiculously high
                 var reasonableTimeLimit = veryRecently + 5000; // 5 seconds from now
                 var win = function (a) {
                     expect(a.timestamp).toBeGreaterThan(veryRecently - 200); // this is flakey, relaxing a bit
                     expect(a.timestamp).toBeLessThan(reasonableTimeLimit);
                     done();
                 };

                 id = navigator.accelerometer.watchAcceleration(win, fail.bind(null, done), { frequency: 100 });
             });

             it('accelerometer.spec.12 success callback should be preserved and called several times', function (done) {
                 // skip the test if Accelerometer doesn't exist on this device
                 if (!isAccelExist) {
                     pending();
                 }
                 var callbacksCallCount = 0;
                 var callbacksCallTestCount = 3;

                 var win = function (a) {
                     if (callbacksCallCount++ < callbacksCallTestCount) return;
                     expect(typeof a).toBe('object');
                     done();
                 };

                 id = navigator.accelerometer.watchAcceleration(win, fail.bind(null, done), { frequency: 100 });
             });
         });

         describe('clearWatch', function () {
             it('accelerometer.spec.10 should exist', function () {
                 expect(navigator.accelerometer.clearWatch).toBeDefined();
                 expect(typeof navigator.accelerometer.clearWatch === 'function').toBe(true);
             });

             it('accelerometer.spec.11 should clear an existing watch', function (done) {
                 // skip the test if Accelerometer doesn't exist on this device
                 if (!isAccelExist) {
                     pending();
                 }
                 var id;

                 // expect win to get called exactly once
                 var win = function (a) {
                     // clear watch on first call
                     navigator.accelerometer.clearWatch(id);
                     // if win isn't called again in 201 ms we assume success
                     var tid = setTimeout(function () {
                         expect(true).toBe(true);
                         done();
                     }, 101);
                     // if win is called again, clear the timeout and fail the test
                     win = function () {
                         clearTimeout(tid);
                         fail(done);
                     };
                 };

                 // wrap the success call in a closure since the value of win changes between calls
                 id = navigator.accelerometer.watchAcceleration(
                     function () {
                         win();
                     },
                     fail.bind(null, done),
                     { frequency: 100 }
                 );
             });
         });
     });
 };

 /******************************************************************************/
 /******************************************************************************/
 /******************************************************************************/

 exports.defineManualTests = function (contentEl, createActionButton) {
     function roundNumber (num) {
         var dec = 3;
         var result = Math.round(num * Math.pow(10, dec)) / Math.pow(10, dec);
         return result;
     }

     var watchAccelId = null;

     /**
      * Set accelerometer status
      */
     function setAccelStatus (status) {
         document.getElementById('accel_status').innerHTML = status;
     }

     /**
      * Stop watching the acceleration
      */
     function stopAccel () {
         console.log('stopAccel()');
         setAccelStatus('Stopped');
         if (watchAccelId) {
             navigator.accelerometer.clearWatch(watchAccelId);
             watchAccelId = null;
         }
     }

     /**
      * Start watching acceleration
      */
     var watchAccel = function () {
         console.log('watchAccel()');

         // Success callback
         var success = function (a) {
             document.getElementById('x').innerHTML = roundNumber(a.x);
             document.getElementById('y').innerHTML = roundNumber(a.y);
             document.getElementById('z').innerHTML = roundNumber(a.z);
             document.getElementById('t').innerHTML = a.timestamp;
         };

         // Fail callback
         var fail = function (e) {
             console.log('watchAccel fail callback with error code ' + e);
             stopAccel();
             setAccelStatus(e);
         };

         // Update acceleration every 1 sec
         var opt = {};
         opt.frequency = 1000;
         watchAccelId = navigator.accelerometer.watchAcceleration(success, fail, opt);

         setAccelStatus('Running');
     };

     /**
      * Get current acceleration
      */
     var getAccel = function () {
         console.log('getAccel()');

         // Stop accel if running
         stopAccel();

         // Success callback
         var success = function (a) {
             document.getElementById('x').innerHTML = roundNumber(a.x);
             document.getElementById('y').innerHTML = roundNumber(a.y);
             document.getElementById('z').innerHTML = roundNumber(a.z);
             document.getElementById('t').innerHTML = a.timestamp;
             console.log('getAccel success callback');
         };

         // Fail callback
         var fail = function (e) {
             console.log('getAccel fail callback with error code ' + e);
             setAccelStatus(e);
         };

         // Make call
         var opt = {};
         navigator.accelerometer.getCurrentAcceleration(success, fail, opt);
     };

     /******************************************************************************/

     var accelerometer_tests =
         '<div id="getAcceleration"></div>' +
         'Expected result: Will update the status box with X, Y, and Z values when pressed. Status will read "Stopped"' +
         '<p/> <div id="watchAcceleration"></div>' +
         'Expected result: When pressed, will start a watch on the accelerometer and update X,Y,Z values when movement is sensed. Status will read "Running"' +
         '<p/> <div id="clearAcceleration"></div>' +
         'Expected result: Will clear the accelerometer watch, so X,Y,Z values will no longer be updated. Status will read "Stopped"';

     contentEl.innerHTML =
         '<div id="info">' +
         'Status: <span id="accel_status">Stopped</span>' +
         '<table width="100%">' +
         '<tr><td width="30%">X:</td><td id="x"> </td></tr>' +
         '<tr><td width="30%">Y:</td><td id="y"> </td></tr>' +
         '<tr><td width="30%">Z:</td><td id="z"> </td></tr>' +
         '<tr><td width="30%">Timestamp:</td><td id="t"> </td></tr>' +
         '</table></div>' +
         accelerometer_tests;

     createActionButton(
         'Get Acceleration',
         function () {
             getAccel();
         },
         'getAcceleration'
     );

     createActionButton(
         'Start Watch',
         function () {
             watchAccel();
         },
         'watchAcceleration'
     );

     createActionButton(
         'Clear Watch',
         function () {
             stopAccel();
         },
         'clearAcceleration'
     );
 };
	/*
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	*/

	/* global cordova, Windows */

	exports.defineAutoTests = function () {
	var isWindows = cordova.platformId === 'windows';
	// Checking existence of accelerometer for windows platform
	// Assumed that accelerometer always exists on other platforms. Extend
	// condition to support accelerometer check on other platforms
	var isAccelExist = isWindows ? Windows.Devices.Sensors.Accelerometer.getDefault() !== null : true;

	describe('Accelerometer (navigator.accelerometer)', function () {
	var fail = function (done) {
	expect(true).toBe(false);
	done();
	};

	// This timeout is here to lessen the load on native accelerometer
	// intensive use of which can lead to occasional test failures
	afterEach(function (done) {
	setTimeout(function () {
	done();
	}, 100);
	});

	it('accelerometer.spec.1 should exist', function () {
	expect(navigator.accelerometer).toBeDefined();
	});

	describe('getCurrentAcceleration', function () {
	it('accelerometer.spec.2 should exist', function () {
	expect(typeof navigator.accelerometer.getCurrentAcceleration).toBeDefined();
	expect(typeof navigator.accelerometer.getCurrentAcceleration === 'function').toBe(true);
	});

	it('accelerometer.spec.3 success callback should be called with an Acceleration object', function (done) {
	// skip the test if Accelerometer doesn't exist on this device
	if (!isAccelExist) {
	pending();
	}
	var win = function (a) {
	expect(a).toBeDefined();
	expect(a.x).toBeDefined();
	expect(typeof a.x === 'number').toBe(true);
	expect(a.y).toBeDefined();
	expect(typeof a.y === 'number').toBe(true);
	expect(a.z).toBeDefined();
	expect(typeof a.z === 'number').toBe(true);
	expect(a.timestamp).toBeDefined();
	expect(typeof a.timestamp).toBe('number');
	done();
	};

	var onError = function (err) {
	console.log(err);
	console.log('Skipping gyroscope tests, marking all as pending.');
	isAccelExist = false;
	expect(true).toBe(true);
	done();
	};

	navigator.accelerometer.getCurrentAcceleration(win, onError);
	});

	it('accelerometer.spec.4 success callback Acceleration object should have (reasonable) values for x, y and z expressed in m/s^2', function (done) {
	// skip the test if Accelerometer doesn't exist on this device
	if (!isAccelExist) {
	pending();
	}
	var reasonableThreshold = 15;
	var win = function (a) {
	expect(a.x).toBeLessThan(reasonableThreshold);
	expect(a.x).toBeGreaterThan(reasonableThreshold * -1);
	expect(a.y).toBeLessThan(reasonableThreshold);
	expect(a.y).toBeGreaterThan(reasonableThreshold * -1);
	expect(a.z).toBeLessThan(reasonableThreshold);
	expect(a.z).toBeGreaterThan(reasonableThreshold * -1);
	done();
	};

	navigator.accelerometer.getCurrentAcceleration(win, fail.bind(null, done));
	});

	it('accelerometer.spec.5 success callback Acceleration object should return a recent timestamp', function (done) {
	// skip the test if Accelerometer doesn't exist on this device
	if (!isAccelExist) {
	pending();
	}
	var veryRecently = new Date().getTime();
	// Need to check that dates returned are not vastly greater than a recent time stamp.
	// In case the timestamps returned are ridiculously high
	var reasonableTimeLimit = veryRecently + 5000; // 5 seconds from now
	var win = function (a) {
	expect(a.timestamp).toBeGreaterThan(veryRecently - 200); // this is flakey, relaxing a bit
	expect(a.timestamp).toBeLessThan(reasonableTimeLimit);
	done();
	};

	navigator.accelerometer.getCurrentAcceleration(win, fail.bind(null, done));
	});
	});

	describe('watchAcceleration', function () {
	var id;

	afterEach(function (done) {
	if (id) {
	navigator.accelerometer.clearWatch(id);
	}
	// clearWatch implementation is async but doesn't accept a cllback
	// so let's give it some time before starting next spec
	setTimeout(done, 100);
	});

	it('accelerometer.spec.6 should exist', function () {
	expect(navigator.accelerometer.watchAcceleration).toBeDefined();
	expect(typeof navigator.accelerometer.watchAcceleration === 'function').toBe(true);
	});

	it('accelerometer.spec.7 success callback should be called with an Acceleration object', function (done) {
	// skip the test if Accelerometer doesn't exist on this device
	if (!isAccelExist) {
	pending();
	}
	var win = function (a) {
	expect(a).toBeDefined();
	expect(a.x).toBeDefined();
	expect(typeof a.x === 'number').toBe(true);
	expect(a.y).toBeDefined();
	expect(typeof a.y === 'number').toBe(true);
	expect(a.z).toBeDefined();
	expect(typeof a.z === 'number').toBe(true);
	expect(a.timestamp).toBeDefined();
	expect(typeof a.timestamp).toBe('number');
	done();
	};

	id = navigator.accelerometer.watchAcceleration(win, fail.bind(null, done), { frequency: 100 });
	});

	it('accelerometer.spec.8 success callback Acceleration object should have (reasonable) values for x, y and z expressed in m/s^2', function (done) {
	// skip the test if Accelerometer doesn't exist on this device
	if (!isAccelExist) {
	pending();
	}
	var reasonableThreshold = 15;
	var win = function (a) {
	expect(a.x).toBeLessThan(reasonableThreshold);
	expect(a.x).toBeGreaterThan(reasonableThreshold * -1);
	expect(a.y).toBeLessThan(reasonableThreshold);
	expect(a.y).toBeGreaterThan(reasonableThreshold * -1);
	expect(a.z).toBeLessThan(reasonableThreshold);
	expect(a.z).toBeGreaterThan(reasonableThreshold * -1);
	done();
	};

	id = navigator.accelerometer.watchAcceleration(win, fail.bind(null, done), { frequency: 100 });
	});

	it('accelerometer.spec.9 success callback Acceleration object should return a recent timestamp', function (done) {
	// skip the test if Accelerometer doesn't exist on this device
	if (!isAccelExist) {
	pending();
	}
	var veryRecently = new Date().getTime();
	// Need to check that dates returned are not vastly greater than a recent time stamp.
	// In case the timestamps returned are ridiculously high
	var reasonableTimeLimit = veryRecently + 5000; // 5 seconds from now
	var win = function (a) {
	expect(a.timestamp).toBeGreaterThan(veryRecently - 200); // this is flakey, relaxing a bit
	expect(a.timestamp).toBeLessThan(reasonableTimeLimit);
	done();
	};

	id = navigator.accelerometer.watchAcceleration(win, fail.bind(null, done), { frequency: 100 });
	});

	it('accelerometer.spec.12 success callback should be preserved and called several times', function (done) {
	// skip the test if Accelerometer doesn't exist on this device
	if (!isAccelExist) {
	pending();
	}
	var callbacksCallCount = 0;
	var callbacksCallTestCount = 3;

	var win = function (a) {
	if (callbacksCallCount++ < callbacksCallTestCount) return;
	expect(typeof a).toBe('object');
	done();
	};

	id = navigator.accelerometer.watchAcceleration(win, fail.bind(null, done), { frequency: 100 });
	});
	});

	describe('clearWatch', function () {
	it('accelerometer.spec.10 should exist', function () {
	expect(navigator.accelerometer.clearWatch).toBeDefined();
	expect(typeof navigator.accelerometer.clearWatch === 'function').toBe(true);
	});

	it('accelerometer.spec.11 should clear an existing watch', function (done) {
	// skip the test if Accelerometer doesn't exist on this device
	if (!isAccelExist) {
	pending();
	}
	var id;

	// expect win to get called exactly once
	var win = function (a) {
	// clear watch on first call
	navigator.accelerometer.clearWatch(id);
	// if win isn't called again in 201 ms we assume success
	var tid = setTimeout(function () {
	expect(true).toBe(true);
	done();
	}, 101);
	// if win is called again, clear the timeout and fail the test
	win = function () {
	clearTimeout(tid);
	fail(done);
	};
	};

	// wrap the success call in a closure since the value of win changes between calls
	id = navigator.accelerometer.watchAcceleration(
	function () {
	win();
	},
	fail.bind(null, done),
	{ frequency: 100 }
	);
	});
	});
	});
	};

	/******************************************************************************/
	/******************************************************************************/
	/******************************************************************************/

	exports.defineManualTests = function (contentEl, createActionButton) {
	function roundNumber (num) {
	var dec = 3;
	var result = Math.round(num * Math.pow(10, dec)) / Math.pow(10, dec);
	return result;
	}

	var watchAccelId = null;

	/**
	* Set accelerometer status
	*/
	function setAccelStatus (status) {
	document.getElementById('accel_status').innerHTML = status;
	}

	/**
	* Stop watching the acceleration
	*/
	function stopAccel () {
	console.log('stopAccel()');
	setAccelStatus('Stopped');
	if (watchAccelId) {
	navigator.accelerometer.clearWatch(watchAccelId);
	watchAccelId = null;
	}
	}

	/**
	* Start watching acceleration
	*/
	var watchAccel = function () {
	console.log('watchAccel()');

	// Success callback
	var success = function (a) {
	document.getElementById('x').innerHTML = roundNumber(a.x);
	document.getElementById('y').innerHTML = roundNumber(a.y);
	document.getElementById('z').innerHTML = roundNumber(a.z);
	document.getElementById('t').innerHTML = a.timestamp;
	};

	// Fail callback
	var fail = function (e) {
	console.log('watchAccel fail callback with error code ' + e);
	stopAccel();
	setAccelStatus(e);
	};

	// Update acceleration every 1 sec
	var opt = {};
	opt.frequency = 1000;
	watchAccelId = navigator.accelerometer.watchAcceleration(success, fail, opt);

	setAccelStatus('Running');
	};

	/**
	* Get current acceleration
	*/
	var getAccel = function () {
	console.log('getAccel()');

	// Stop accel if running
	stopAccel();

	// Success callback
	var success = function (a) {
	document.getElementById('x').innerHTML = roundNumber(a.x);
	document.getElementById('y').innerHTML = roundNumber(a.y);
	document.getElementById('z').innerHTML = roundNumber(a.z);
	document.getElementById('t').innerHTML = a.timestamp;
	console.log('getAccel success callback');
	};

	// Fail callback
	var fail = function (e) {
	console.log('getAccel fail callback with error code ' + e);
	setAccelStatus(e);
	};

	// Make call
	var opt = {};
	navigator.accelerometer.getCurrentAcceleration(success, fail, opt);
	};

	/******************************************************************************/

	var accelerometer_tests =
	'<div id="getAcceleration"></div>' +
	'Expected result: Will update the status box with X, Y, and Z values when pressed. Status will read "Stopped"' +
	'<p/> <div id="watchAcceleration"></div>' +
	'Expected result: When pressed, will start a watch on the accelerometer and update X,Y,Z values when movement is sensed. Status will read "Running"' +
	'<p/> <div id="clearAcceleration"></div>' +
	'Expected result: Will clear the accelerometer watch, so X,Y,Z values will no longer be updated. Status will read "Stopped"';

	contentEl.innerHTML =
	'<div id="info">' +
	'Status: <span id="accel_status">Stopped</span>' +
	'<table width="100%">' +
	'<tr><td width="30%">X:</td><td id="x"> </td></tr>' +
	'<tr><td width="30%">Y:</td><td id="y"> </td></tr>' +
	'<tr><td width="30%">Z:</td><td id="z"> </td></tr>' +
	'<tr><td width="30%">Timestamp:</td><td id="t"> </td></tr>' +
	'</table></div>' +
	accelerometer_tests;

	createActionButton(
	'Get Acceleration',
	function () {
	getAccel();
	},
	'getAcceleration'
	);

	createActionButton(
	'Start Watch',
	function () {
	watchAccel();
	},
	'watchAcceleration'
	);

	createActionButton(
	'Clear Watch',
	function () {
	stopAccel();
	},
	'clearAcceleration'
	);
	};