Change test case

test/test-0.7.0.js

@@ -19,7 +19,7 @@ const { Assert, Comparer, Info, prop } = RNTest
 const describe = RNTest.config({
   group : '0.7.0',
   run : true,
-  expand : true,
+  expand : false,
   timeout : 300000000,
 })
 const { TEST_SERVER_URL, TEST_SERVER_URL_SSL, DROPBOX_TOKEN, styles } = prop()

test/test-0.8.2.js

@@ -83,5 +83,5 @@ RNTest.config({
   setTimeout(() => {
     report(<Assert key="request does not retry" expect={1} actual={count}/>)
     done()
-  }, 12000)
+  }, 8000)
 })

test/test-init.js

@@ -33,7 +33,7 @@ const { TEST_SERVER_URL, FILENAME, DROPBOX_TOKEN, styles, image } = prop()
 
 const describe = RNTest.config({
   run : true,
-  expand : false,
+  expand : true,
   timeout : 5000,
 })
 
@@ -70,6 +70,6 @@ describe('GET image from server', (report, done) => {
 // require('./test-fs')
 require('./test-xmlhttp')
 // require('./test-blob')
-require('./test-firebase')
+// require('./test-firebase')
 // require('./test-android')
 // require('./benchmark')

test/test-xmlhttp.js

@@ -39,241 +39,241 @@ let file = RNTest.prop('image')
  * {@link https://github.com/w3c/web-platform-tests/blob/master/XMLHttpRequest/}
  */
 
-describe('unsent state test', (report, done) => {
-
-  let xhr = new XMLHttpRequest()
-
-  try {
-    xhr.setRequestHeader('x-test', 'test')
-  } catch(err) {
-    report(
-      <Assert key="should throw InvalidState if setRequestHeader()"
-        actual={/invalidstate/i.test(err)}
-        expect={true}
-      />)
-  }
-
-  try {
-    let xhr = new XMLHttpRequest()
-    xhr.send(null)
-  } catch(err) {
-    report(
-      <Assert key="should throw InvalidState if send()"
-        actual={/invalidstate/i.test(err)}
-        expect={true}
-      />)
-  }
-  try {
-    report(
-      <Assert key="status is 0"
-        expect={0}
-        actual={xhr.status} />,
-      <Assert key="statusText is empty"
-        expect={''}
-        actual={xhr.statusText} />,
-      <Assert key="responseHeaders is empty"
-        expect={''}
-        actual={xhr.getAllResponseHeaders()} />,
-      <Assert key="response header should not be set"
-        expect={null}
-        actual={xhr.getResponseHeader('x-test')} />,
-      <Assert key="readyState should correct"
-        expect={XMLHttpRequest.UNSENT}
-        actual={xhr.readyState} />
-    )
-    done()
-  } catch(err) {
-    console.log(err.stack)
-  }
-})
-
-describe('HTTP error should not throw error event', (report, done) => {
-
-  onError('GET', 200)
-  onError('GET', 400)
-  onError('GET', 401)
-  onError('GET', 404)
-  onError('GET', 410)
-  onError('GET', 500)
-  onError('GET', 699)
-
-  onError('HEAD', 200)
-  onError('HEAD', 404)
-  onError('HEAD', 500)
-  onError('HEAD', 699)
-
-  onError('POST', 200)
-  onError('POST', 404)
-  onError('POST', 500)
-  onError('POST', 699)
-
-  onError('PUT', 200)
-  onError('PUT', 404)
-  onError('PUT', 500)
-  onError('PUT', 699)
-
-  done()
-
-  let count = 0
-  function onError(method, code) {
-    let xhr = new XMLHttpRequest()
-    xhr.open(method, `${TEST_SERVER_URL}/xhr-code/${code}`)
-    xhr.onreadystatechange = function() {
-      count++
-      if(this.readyState == XMLHttpRequest.DONE) {
-        report(
-          <Assert
-            key={`#${count} response data of ${method} ${code} should be empty`}
-            expect=""
-            actual={xhr.response}/>,
-          <Assert
-            key={`#${count} status of ${method} ${code} should be ${code}`}
-            expect={code}
-            actual={xhr.status}/>
-        )
-      }
-    }
-    xhr.onerror = function() {
-      report(
-        <Assert
-          key={`HTTP error ${code} should not throw error event`}
-          expect={false}
-          actual={true}/>)
-    }
-    xhr.send()
-  }
-
-})
-
-describe('request headers records should be cleared by open()', (report, done) => {
-  let xhr = new XMLHttpRequest()
-  xhr.open('GET', `${TEST_SERVER_URL}/xhr-header`)
-  xhr.setRequestHeader('value', '100')
-  xhr.open('GET', `${TEST_SERVER_URL}/xhr-header`)
-  xhr.setRequestHeader('value', '200')
-  xhr.send()
-  xhr.onreadystatechange = function() {
-    if(this.readyState == 4) {
-      report(<Assert key="headers should be cleared by open()"
-        expect={'200'}
-        actual={this.response['value']}/>)
-      done()
-    }
-  }
-})
-
-/**
- *  {@link https://github.com/w3c/web-platform-tests/blob/master/XMLHttpRequest/setrequestheader-bogus-name.htm}
- */
-describe('invalid characters should not exists in header field', (report, done) => {
-  function try_name(name) {
-    try {
-      let client = new XMLHttpRequest()
-      client.open("GET", `${TEST_SERVER_URL}/public/github.png`)
-      client.setRequestHeader(name, '123')
-    } catch(err) {
-      report(
-        <Assert key={`invalid header type ${name} should throw SyntaxError`}
-          actual={/syntaxerror/i.test(err)}
-          expect={true}
-        />)
-    }
-  }
-  function try_byte_string(name) {
-    try {
-      let client = new XMLHttpRequest()
-      client.open("GET", `${TEST_SERVER_URL}/public/github.png`)
-      client.setRequestHeader(name, '123')
-    } catch(err) {
-      report(
-        <Assert key={`invalid header field ${name} type should throw TypeError`}
-          actual={/typeerror/i.test(err)}
-          expect={true}
-        />)
-    }
-  }
-  var invalid_headers = ["(", ")", "<", ">", "@", ",", ";", ":", "\\",
-                         "\"", "/", "[", "]", "?", "=", "{", "}", " ",
-                         "\u007f", "", "t\rt", "t\nt", "t: t", "t:t",
-                         "t<t", "t t", " tt", ":tt", "\ttt", "\vtt", "t\0t",
-                         "t\"t", "t,t", "t;t", "()[]{}", "a?B", "a=B"]
-  var invalid_byte_strings = ["ﾃｽﾄ", "X-ﾃｽﾄ"]
-  for (var i = 0; i < 32; ++i) {
-    invalid_headers.push(String.fromCharCode(i))
-  }
-  for (var i = 0; i < invalid_headers.length; ++i) {
-    try_name(invalid_headers[i])
-  }
-  for (var i = 0; i < invalid_byte_strings.length; ++i) {
-    try_byte_string(invalid_byte_strings[i])
-  }
-  done()
-
-})
-
-describe('invoke setRequestHeader() before open()', (report, done) => {
-  try {
-    let xhr = new XMLHttpRequest()
-    xhr.setRequestHeader('foo', 'bar')
-  } catch(err) {
-    report(
-      <Info key="error message">
-        <Text>{err}</Text>
-      </Info>,
-      <Assert key="should throw InvalidStateError"
-        expect={true}
-        actual={/invalidstateerror/i.test(err)}/>)
-      done()
-  }
-})
-
-describe('upload progress event test', (report, done) => {
-  let xhr = new XMLHttpRequest()
-  let time = Date.now()
-  let msg =  `time=${time}`
-  xhr.upload.onprogress = function(e) {
-    report(
-      <Assert key="event object is an instance of ProgressEvent"
-        expect={true}
-        actual={e instanceof ProgressEvent}/>)
-  }
-  xhr.onreadystatechange = function() {
-    if(this.readyState == XMLHttpRequest.DONE) {
-      console.log(xhr)
-      report(
-        <Assert key="reponse should correct"
-          expect={time}
-          actual={parseInt(xhr.response.time)}/>,
-        <Assert key="responseType should correct"
-          expect={'json'}
-          actual={xhr.responseType}/>)
-        done()
-    }
-  }
-  xhr.open('POST', `${TEST_SERVER_URL}/upload`)
-  xhr.overrideMimeType('application/x-www-form-urlencoded')
-  xhr.send(msg)
-
-})
-
-describe('timeout event catchable', (report, done) => {
-  let xhr = new XMLHttpRequest()
-  let count = 0
-  xhr.timeout = 1
-  xhr.ontimeout = function() {
-    report(
-      <Info key="event should only trigger once" uid="1000">
-        <Text>{count}</Text>
-      </Info>,
-      <Assert key="event catchable"
-        expect={true}
-        actual={true}/>)
-      done()
-  }
-  xhr.open('GET', `${TEST_SERVER_URL}/timeout/`)
-  xhr.send()
-
-})
+// describe('unsent state test', (report, done) => {
+//
+//   let xhr = new XMLHttpRequest()
+//
+//   try {
+//     xhr.setRequestHeader('x-test', 'test')
+//   } catch(err) {
+//     report(
+//       <Assert key="should throw InvalidState if setRequestHeader()"
+//         actual={/invalidstate/i.test(err)}
+//         expect={true}
+//       />)
+//   }
+//
+//   try {
+//     let xhr = new XMLHttpRequest()
+//     xhr.send(null)
+//   } catch(err) {
+//     report(
+//       <Assert key="should throw InvalidState if send()"
+//         actual={/invalidstate/i.test(err)}
+//         expect={true}
+//       />)
+//   }
+//   try {
+//     report(
+//       <Assert key="status is 0"
+//         expect={0}
+//         actual={xhr.status} />,
+//       <Assert key="statusText is empty"
+//         expect={''}
+//         actual={xhr.statusText} />,
+//       <Assert key="responseHeaders is empty"
+//         expect={''}
+//         actual={xhr.getAllResponseHeaders()} />,
+//       <Assert key="response header should not be set"
+//         expect={null}
+//         actual={xhr.getResponseHeader('x-test')} />,
+//       <Assert key="readyState should correct"
+//         expect={XMLHttpRequest.UNSENT}
+//         actual={xhr.readyState} />
+//     )
+//     done()
+//   } catch(err) {
+//     console.log(err.stack)
+//   }
+// })
+//
+// describe('HTTP error should not throw error event', (report, done) => {
+//
+//   onError('GET', 200)
+//   onError('GET', 400)
+//   onError('GET', 401)
+//   onError('GET', 404)
+//   onError('GET', 410)
+//   onError('GET', 500)
+//   onError('GET', 699)
+//
+//   onError('HEAD', 200)
+//   onError('HEAD', 404)
+//   onError('HEAD', 500)
+//   onError('HEAD', 699)
+//
+//   onError('POST', 200)
+//   onError('POST', 404)
+//   onError('POST', 500)
+//   onError('POST', 699)
+//
+//   onError('PUT', 200)
+//   onError('PUT', 404)
+//   onError('PUT', 500)
+//   onError('PUT', 699)
+//
+//   done()
+//
+//   let count = 0
+//   function onError(method, code) {
+//     let xhr = new XMLHttpRequest()
+//     xhr.open(method, `${TEST_SERVER_URL}/xhr-code/${code}`)
+//     xhr.onreadystatechange = function() {
+//       count++
+//       if(this.readyState == XMLHttpRequest.DONE) {
+//         report(
+//           <Assert
+//             key={`#${count} response data of ${method} ${code} should be empty`}
+//             expect=""
+//             actual={xhr.response}/>,
+//           <Assert
+//             key={`#${count} status of ${method} ${code} should be ${code}`}
+//             expect={code}
+//             actual={xhr.status}/>
+//         )
+//       }
+//     }
+//     xhr.onerror = function() {
+//       report(
+//         <Assert
+//           key={`HTTP error ${code} should not throw error event`}
+//           expect={false}
+//           actual={true}/>)
+//     }
+//     xhr.send()
+//   }
+//
+// })
+//
+// describe('request headers records should be cleared by open()', (report, done) => {
+//   let xhr = new XMLHttpRequest()
+//   xhr.open('GET', `${TEST_SERVER_URL}/xhr-header`)
+//   xhr.setRequestHeader('value', '100')
+//   xhr.open('GET', `${TEST_SERVER_URL}/xhr-header`)
+//   xhr.setRequestHeader('value', '200')
+//   xhr.send()
+//   xhr.onreadystatechange = function() {
+//     if(this.readyState == 4) {
+//       report(<Assert key="headers should be cleared by open()"
+//         expect={'200'}
+//         actual={this.response['value']}/>)
+//       done()
+//     }
+//   }
+// })
+//
+// /**
+//  *  {@link https://github.com/w3c/web-platform-tests/blob/master/XMLHttpRequest/setrequestheader-bogus-name.htm}
+//  */
+// describe('invalid characters should not exists in header field', (report, done) => {
+//   function try_name(name) {
+//     try {
+//       let client = new XMLHttpRequest()
+//       client.open("GET", `${TEST_SERVER_URL}/public/github.png`)
+//       client.setRequestHeader(name, '123')
+//     } catch(err) {
+//       report(
+//         <Assert key={`invalid header type ${name} should throw SyntaxError`}
+//           actual={/syntaxerror/i.test(err)}
+//           expect={true}
+//         />)
+//     }
+//   }
+//   function try_byte_string(name) {
+//     try {
+//       let client = new XMLHttpRequest()
+//       client.open("GET", `${TEST_SERVER_URL}/public/github.png`)
+//       client.setRequestHeader(name, '123')
+//     } catch(err) {
+//       report(
+//         <Assert key={`invalid header field ${name} type should throw TypeError`}
+//           actual={/typeerror/i.test(err)}
+//           expect={true}
+//         />)
+//     }
+//   }
+//   var invalid_headers = ["(", ")", "<", ">", "@", ",", ";", ":", "\\",
+//                          "\"", "/", "[", "]", "?", "=", "{", "}", " ",
+//                          "\u007f", "", "t\rt", "t\nt", "t: t", "t:t",
+//                          "t<t", "t t", " tt", ":tt", "\ttt", "\vtt", "t\0t",
+//                          "t\"t", "t,t", "t;t", "()[]{}", "a?B", "a=B"]
+//   var invalid_byte_strings = ["ﾃｽﾄ", "X-ﾃｽﾄ"]
+//   for (var i = 0; i < 32; ++i) {
+//     invalid_headers.push(String.fromCharCode(i))
+//   }
+//   for (var i = 0; i < invalid_headers.length; ++i) {
+//     try_name(invalid_headers[i])
+//   }
+//   for (var i = 0; i < invalid_byte_strings.length; ++i) {
+//     try_byte_string(invalid_byte_strings[i])
+//   }
+//   done()
+//
+// })
+//
+// describe('invoke setRequestHeader() before open()', (report, done) => {
+//   try {
+//     let xhr = new XMLHttpRequest()
+//     xhr.setRequestHeader('foo', 'bar')
+//   } catch(err) {
+//     report(
+//       <Info key="error message">
+//         <Text>{err}</Text>
+//       </Info>,
+//       <Assert key="should throw InvalidStateError"
+//         expect={true}
+//         actual={/invalidstateerror/i.test(err)}/>)
+//       done()
+//   }
+// })
+//
+// describe('upload progress event test', (report, done) => {
+//   let xhr = new XMLHttpRequest()
+//   let time = Date.now()
+//   let msg =  `time=${time}`
+//   xhr.upload.onprogress = function(e) {
+//     report(
+//       <Assert key="event object is an instance of ProgressEvent"
+//         expect={true}
+//         actual={e instanceof ProgressEvent}/>)
+//   }
+//   xhr.onreadystatechange = function() {
+//     if(this.readyState == XMLHttpRequest.DONE) {
+//       console.log(xhr)
+//       report(
+//         <Assert key="reponse should correct"
+//           expect={time}
+//           actual={parseInt(xhr.response.time)}/>,
+//         <Assert key="responseType should correct"
+//           expect={'json'}
+//           actual={xhr.responseType}/>)
+//         done()
+//     }
+//   }
+//   xhr.open('POST', `${TEST_SERVER_URL}/upload`)
+//   xhr.overrideMimeType('application/x-www-form-urlencoded')
+//   xhr.send(msg)
+//
+// })
+//
+// describe('timeout event catchable', (report, done) => {
+//   let xhr = new XMLHttpRequest()
+//   let count = 0
+//   xhr.timeout = 1
+//   xhr.ontimeout = function() {
+//     report(
+//       <Info key="event should only trigger once" uid="1000">
+//         <Text>{count}</Text>
+//       </Info>,
+//       <Assert key="event catchable"
+//         expect={true}
+//         actual={true}/>)
+//       done()
+//   }
+//   xhr.open('GET', `${TEST_SERVER_URL}/timeout/`)
+//   xhr.send()
+//
+// })
 
 describe('upload progress event should not be triggered when body is empty', (report, done) => {
   let xhr = new XMLHttpRequest()