Updates from Wed 18 Mar

- [ReactNative] Add AsyncStorageTest | Spencer Ahrens
- [ReactNative] Add timers integration test | Spencer Ahrens
- [ReactNative] Remove ExpandingText | Tadeu Zagallo
- [TouchableHighlight] Preserve underlay style when restoring inactive props | Christopher Chedeau
- clean flow errors in react-native-github | Basil Hosmer
- [ReactNative] Sort React Native exports into two groups, Components and APIs | Christopher Chedeau
- [ReactNative] Rename Slider to SliderIOS | Tadeu Zagallo
- [react_native] JS files from D1919491: Improve JS logging | Martin Kosiba
- [ReactNative] Add TimerExample | Spencer Ahrens
- [RFC][ReactNative] increase timer resolution | Spencer Ahrens
- [ReactNative] Strip prefixes from NativeModules keys | Spencer Ahrens
- [ReactNative] Small docs cleanup in ActivityIndicatorIOS and DatePickerIOS | Christopher Chedeau
- [ReactNative] Improvements on perf measurement output | Jing Chen
- [ReactNative] Clean up Touchable PropTypes | Christopher Chedeau
- [ReactKit] Fail tests when redbox shows up | Alex Kotliarskyi

IntegrationTests/AsyncStorageTest.js

@@ -0,0 +1,148 @@
+/**
+ * Copyright 2004-present Facebook. All Rights Reserved.
+ */
+'use strict';
+
+var RCTTestModule = require('NativeModules').TestModule;
+var React = require('react-native');
+var {
+  AsyncStorage,
+  Text,
+  View,
+} = React;
+
+var DEBUG = false;
+
+var KEY_1 = 'key_1';
+var VAL_1 = 'val_1';
+var KEY_2 = 'key_2';
+var VAL_2 = 'val_2';
+
+// setup in componentDidMount
+var done;
+var updateMessage;
+
+function runTestCase(description, fn) {
+  updateMessage(description);
+  fn();
+}
+
+function expectTrue(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+function expectEqual(lhs, rhs, testname) {
+  expectTrue(
+    lhs === rhs,
+    'Error in test ' + testname + ': expected ' + rhs + ', got ' + lhs
+  );
+}
+
+function expectAsyncNoError(err) {
+  expectTrue(err === null, 'Unexpected Async error: ' + JSON.stringify(err));
+}
+
+function testSetAndGet() {
+  AsyncStorage.setItem(KEY_1, VAL_1, (err1) => {
+    expectAsyncNoError(err1);
+    AsyncStorage.getItem(KEY_1, (err2, result) => {
+      expectAsyncNoError(err2);
+      expectEqual(result, VAL_1, 'testSetAndGet setItem');
+      updateMessage('get(key_1) correctly returned ' + result);
+      runTestCase('should get null for missing key', testMissingGet);
+    });
+  });
+}
+
+function testMissingGet() {
+  AsyncStorage.getItem(KEY_2, (err, result) => {
+    expectAsyncNoError(err);
+    expectEqual(result, null, 'testMissingGet');
+    updateMessage('missing get(key_2) correctly returned ' + result);
+    runTestCase('check set twice results in a single key', testSetTwice);
+  });
+}
+
+function testSetTwice() {
+  AsyncStorage.setItem(KEY_1, VAL_1, ()=>{
+    AsyncStorage.setItem(KEY_1, VAL_1, ()=>{
+      AsyncStorage.getItem(KEY_1, (err, result) => {
+        expectAsyncNoError(err);
+        expectEqual(result, VAL_1, 'testSetTwice');
+        updateMessage('setTwice worked as expected');
+        runTestCase('test removeItem', testRemoveItem);
+      });
+    });
+  });
+}
+
+function testRemoveItem() {
+  AsyncStorage.setItem(KEY_1, VAL_1, ()=>{
+    AsyncStorage.setItem(KEY_2, VAL_2, ()=>{
+      AsyncStorage.getAllKeys((err, result) => {
+        expectAsyncNoError(err);
+        expectTrue(
+          result.indexOf(KEY_1) >= 0 && result.indexOf(KEY_2) >= 0,
+          'Missing KEY_1 or KEY_2 in ' + '(' + result + ')'
+        );
+        updateMessage('testRemoveItem - add two items');
+        AsyncStorage.removeItem(KEY_1, (err) => {
+          expectAsyncNoError(err);
+          updateMessage('delete successful ');
+          AsyncStorage.getItem(KEY_1, (err, result) => {
+            expectAsyncNoError(err);
+            expectEqual(
+              result,
+              null,
+              'testRemoveItem: key_1 present after delete'
+            );
+            updateMessage('key properly removed ');
+            AsyncStorage.getAllKeys((err, result2) => {
+             expectAsyncNoError(err);
+             expectTrue(
+               result2.indexOf(KEY_1) === -1,
+               'Unexpected: KEY_1 present in ' + result2
+             );
+             updateMessage('proper length returned.\nDone!');
+             done();
+            });
+          });
+        });
+      });
+    });
+  });
+}
+
+var AsyncStorageTest = React.createClass({
+  getInitialState() {
+    return {
+      messages: 'Initializing...',
+      done: false,
+    };
+  },
+
+  componentDidMount() {
+    done = () => this.setState({done: true}, RCTTestModule.markTestCompleted);
+    updateMessage = (msg) => {
+      this.setState({messages: this.state.messages.concat('\n' + msg)});
+      DEBUG && console.log(msg);
+    };
+    AsyncStorage.clear(testSetAndGet);
+  },
+
+  render() {
+    return (
+      <View style={{backgroundColor: 'white', padding: 40}}>
+        <Text>
+          {this.constructor.displayName + ': '}
+          {this.state.done ? 'Done' : 'Testing...'}
+          {'\n\n' + this.state.messages}
+        </Text>
+      </View>
+    );
+  }
+});
+
+module.exports = AsyncStorageTest;

IntegrationTests/IntegrationTestHarnessTest.js

@@ -3,7 +3,7 @@
  */
 'use strict';
 
-var RCTTestModule = require('NativeModules').RCTTestModule;
+var RCTTestModule = require('NativeModules').TestModule;
 var React = require('react-native');
 var {
   Text,

IntegrationTests/IntegrationTestsApp.js

@@ -18,6 +18,8 @@ var {
 
 var TESTS = [
   require('./IntegrationTestHarnessTest'),
+  require('./TimersTest'),
+  require('./AsyncStorageTest'),
 ];
 
 TESTS.forEach(

IntegrationTests/IntegrationTestsTests/IntegrationTestsTests.m

@@ -37,4 +37,14 @@
   expectErrorRegex:[NSRegularExpression regularExpressionWithPattern:@"because shouldThrow" options:0 error:nil]];
 }
 
+- (void)testTimers
+{
+  [_runner runTest:@"TimersTest"];
+}
+
+- (void)testAsyncStorage
+{
+  [_runner runTest:@"AsyncStorageTest"];
+}
+
 @end

IntegrationTests/TimersTest.js

@@ -0,0 +1,150 @@
+/**
+ * Copyright 2004-present Facebook. All Rights Reserved.
+ */
+'use strict';
+
+var RCTTestModule = require('NativeModules').TestModule;
+var React = require('react-native');
+var {
+  StyleSheet,
+  Text,
+  TimerMixin,
+  View,
+} = React;
+
+var TimersTest = React.createClass({
+  mixins: [TimerMixin],
+
+  getInitialState() {
+    return {
+      count: 0,
+      done: false,
+    };
+  },
+
+  componentDidMount() {
+    this.testSetTimeout0();
+  },
+
+  testSetTimeout0() {
+    this.setTimeout(this.testSetTimeout1, 0);
+  },
+
+  testSetTimeout1() {
+    this.setTimeout(this.testSetTimeout50, 1);
+  },
+
+  testSetTimeout50() {
+    this.setTimeout(this.testRequestAnimationFrame, 50);
+  },
+
+  testRequestAnimationFrame() {
+    this.requestAnimationFrame(this.testSetInterval0);
+  },
+
+  testSetInterval0() {
+    this._nextTest = this.testSetInterval20;
+    this._interval = this.setInterval(this._incrementInterval, 0);
+  },
+
+  testSetInterval20() {
+    this._nextTest = this.testSetImmediate;
+    this._interval = this.setInterval(this._incrementInterval, 20);
+  },
+
+  testSetImmediate() {
+    this.setImmediate(this.testClearTimeout0);
+  },
+
+  testClearTimeout0() {
+    var timeout = this.setTimeout(() => this._fail('testClearTimeout0'), 0);
+    this.clearTimeout(timeout);
+    this.testClearTimeout30();
+  },
+
+  testClearTimeout30() {
+    var timeout = this.setTimeout(() => this._fail('testClearTimeout30'), 30);
+    this.clearTimeout(timeout);
+    this.setTimeout(this.testClearMulti, 50);
+  },
+
+  testClearMulti() {
+    var fails = [this.setTimeout(() => this._fail('testClearMulti-1'), 20)];
+    fails.push(this.setTimeout(() => this._fail('testClearMulti-2'), 50));
+    var delayClear = this.setTimeout(() => this._fail('testClearMulti-3'), 50);
+    fails.push(this.setTimeout(() => this._fail('testClearMulti-4'), 0));
+
+    this.setTimeout(this.testOrdering, 100); // Next test interleaved
+
+    fails.push(this.setTimeout(() => this._fail('testClearMulti-5'), 10));
+
+    fails.forEach((timeout) => this.clearTimeout(timeout));
+    this.setTimeout(() => this.clearTimeout(delayClear), 20);
+  },
+
+  testOrdering() {
+    // Clear timers are set first because it's more likely to uncover bugs.
+    var fail0;
+    this.setImmediate(() => this.clearTimeout(fail0));
+    fail0 = this.setTimeout(
+      () => this._fail('testOrdering-t0, setImmediate should happen before ' +
+        'setTimeout 0'),
+      0
+    );
+    var failAnim; // This should fail without the t=0 fastpath feature.
+    this.setTimeout(() => this.cancelAnimationFrame(failAnim), 0);
+    failAnim = this.requestAnimationFrame(
+      () => this._fail('testOrdering-Anim, setTimeout 0 should happen before ' +
+        'requestAnimationFrame')
+    );
+    var fail50;
+    this.setTimeout(() => this.clearTimeout(fail50), 20);
+    fail50 = this.setTimeout(
+      () => this._fail('testOrdering-t50, setTimeout 20 should happen before ' +
+        'setTimeout 50'),
+      50
+    );
+    this.setTimeout(this.done, 75);
+  },
+
+  done() {
+    this.setState({done: true}, RCTTestModule.markTestCompleted);
+  },
+
+  render() {
+    return (
+      <View style={styles.container}>
+        <Text>
+          {this.constructor.displayName + ': \n'}
+          Intervals: {this.state.count + '\n'}
+          {this.state.done ? 'Done' : 'Testing...'}
+        </Text>
+      </View>
+    );
+  },
+
+  _incrementInterval() {
+    if (this.state.count > 3) {
+      throw new Error('interval incremented past end.');
+    }
+    if (this.state.count === 3) {
+      this.clearInterval(this._interval);
+      this.setState({count: 0}, this._nextTest);
+      return;
+    }
+    this.setState({count: this.state.count + 1});
+  },
+
+  _fail(caller) {
+    throw new Error('_fail called by ' + caller);
+  },
+});
+
+var styles = StyleSheet.create({
+  container: {
+    backgroundColor: 'white',
+    padding: 40,
+  },
+});
+
+module.exports = TimersTest;