add test renderer chinese translation

Author: ChloeLiang

content/docs/reference-test-renderer.md

@@ -6,20 +6,20 @@ layout: docs
 category: Reference
 ---
 
-**Importing**
+**如何引入**
 
 ```javascript
 import TestRenderer from 'react-test-renderer'; // ES6
 const TestRenderer = require('react-test-renderer'); // ES5 with npm
 ```
 
-## Overview {#overview}
+## 概览 {#overview}
 
-This package provides a React renderer that can be used to render React components to pure JavaScript objects, without depending on the DOM or a native mobile environment.
+这个 package 提供了一个 React 渲染器，可以用来将 React 组件渲染成纯 JavaScript 对象, 无需依赖 DOM 或原生移动环境。
 
-Essentially, this package makes it easy to grab a snapshot of the platform view hierarchy (similar to a DOM tree) rendered by a React DOM or React Native component without using a browser or [jsdom](https://github.com/tmpvar/jsdom).
+本质上, 这个 package 无需利用浏览器或 [jsdom](https://github.com/tmpvar/jsdom) 便可以轻松抓取由 React DOM 或 React Native 渲染出的平台试图层次结构（类似 DOM 树）。
 
-Example:
+示例:
 
 ```javascript
 import TestRenderer from 'react-test-renderer';
@@ -38,9 +38,9 @@ console.log(testRenderer.toJSON());
 //   children: [ 'Facebook' ] }
 ```
 
-You can use Jest's snapshot testing feature to automatically save a copy of the JSON tree to a file and check in your tests that it hasn't changed: [Learn more about it](http://facebook.github.io/jest/blog/2016/07/27/jest-14.html).
+你可以使用 Jest 的快照测试来自动保存一个该 `JSON` 树文件的副本，并在你的测试中检查它是否被更改：[了解更多](http://facebook.github.io/jest/blog/2016/07/27/jest-14.html)。
 
-You can also traverse the output to find specific nodes and make assertions about them.
+你也可以通过遍历输出来查找特定节点，并对它们进行断言。
 
 ```javascript
 import TestRenderer from 'react-test-renderer';
@@ -94,157 +94,155 @@ expect(testInstance.findByProps({className: "sub"}).children).toEqual(['Sub']);
 * [`testInstance.parent`](#testinstanceparent)
 * [`testInstance.children`](#testinstancechildren)
 
-## Reference {#reference}
+## 参考 {#reference}
 
 ### `TestRenderer.create()` {#testrenderercreate}
 
 ```javascript
 TestRenderer.create(element, options);
 ```
 
-Create a `TestRenderer` instance with the passed React element. It doesn't use the real DOM, but it still fully renders the component tree into memory so you can make assertions about it. The returned instance has the following methods and properties.
+通过传来的 React 元素创建一个 `TestRenderer` 实例。它并不使用真实的 DOM，但是它依然将组件树完整地渲染到内存，以便于你对它进行断言。返回的实例拥有以下的方法和属性。
 
 ### `testRenderer.toJSON()` {#testrenderertojson}
 
 ```javascript
 testRenderer.toJSON()
 ```
 
-Return an object representing the rendered tree. This tree only contains the platform-specific nodes like `<div>` or `<View>` and their props, but doesn't contain any user-written components. This is handy for [snapshot testing](http://facebook.github.io/jest/docs/en/snapshot-testing.html#snapshot-testing-with-jest).
+返回一个表示渲染后的树的对象。该树仅包含特定平台的节点，例如 `<div>` 或 `<View>` 和他们的 props，但并不包含任何用户编写的组件。这对于[快照测试](http://facebook.github.io/jest/docs/en/snapshot-testing.html#snapshot-testing-with-jest)非常方便。
 
 ### `testRenderer.toTree()` {#testrenderertotree}
 
 ```javascript
 testRenderer.toTree()
 ```
 
-Return an object representing the rendered tree. Unlike `toJSON()`, the representation is more detailed than the one provided by `toJSON()`, and includes the user-written components. You probably don't need this method unless you're writing your own assertion library on top of the test renderer.
+返回一个表示渲染后的树的对象。和 `toJSON()` 不同，它表示的内容比 `toJSON()` 提供的内容要更加详细，并且包含用户编写的组件。除非你要在测试渲染器（test renderer）之上编写自己的断言库，否则你可能并不需要这个方法。
 
 ### `testRenderer.update()` {#testrendererupdate}
 
 ```javascript
 testRenderer.update(element)
 ```
 
-Re-render the in-memory tree with a new root element. This simulates a React update at the root. If the new element has the same type and key as the previous element, the tree will be updated; otherwise, it will re-mount a new tree.
+使用新的根元素重新渲染内存中的树。它模拟根元素的一次React更新。如果新的元素和之前的元素有相同的 type 和 key，该树将会被更新；否则，它将重挂载一个新树。
 
 ### `testRenderer.unmount()` {#testrendererunmount}
 
 ```javascript
 testRenderer.unmount()
 ```
 
-Unmount the in-memory tree, triggering the appropriate lifecycle events.
+卸载内存中的树，触发相应的生命周期事件。
 
 ### `testRenderer.getInstance()` {#testrenderergetinstance}
 
 ```javascript
 testRenderer.getInstance()
 ```
 
-Return the instance corresponding to the root element, if available. This will not work if the root element is a function component because they don't have instances.
+如果可用的话，返回与根元素相对应的实例。如果根元素是函数定义组件，该方法无效，因为函数定义组件没有实例。
 
 ### `testRenderer.root` {#testrendererroot}
 
 ```javascript
 testRenderer.root
 ```
 
-Returns the root "test instance" object that is useful for making assertions about specific nodes in the tree. You can use it to find other "test instances" deeper below.
+返回根元素“测试实例”对象，它对于断言树中的特定节点十分有用。你可以利用它来查找其他更深层的“测试实例”。
 
 ### `testInstance.find()` {#testinstancefind}
 
 ```javascript
 testInstance.find(test)
 ```
 
-Find a single descendant test instance for which `test(testInstance)` returns `true`. If `test(testInstance)` does not return `true` for exactly one test instance, it will throw an error.
+找到一个 `test(testInstance)` 返回 `true` 的后代测试实例。如果 `test(testInstance)` 没有只对一个测试实例返回 `true`，将会报错。
 
 ### `testInstance.findByType()` {#testinstancefindbytype}
 
 ```javascript
 testInstance.findByType(type)
 ```
 
-Find a single descendant test instance with the provided `type`. If there is not exactly one test instance with the provided `type`, it will throw an error.
+找到匹配指定 `type` 的后代测试实例，如果不是只有一个测试实例匹配指定的 `type`，将会报错。
 
 ### `testInstance.findByProps()` {#testinstancefindbyprops}
 
 ```javascript
 testInstance.findByProps(props)
 ```
 
-Find a single descendant test instance with the provided `props`. If there is not exactly one test instance with the provided `props`, it will throw an error.
+找到匹配指定 `props`的后代测试实例，如果不是正好只有一个测试实例匹配指定的 `props`，将会报错。
 
 ### `testInstance.findAll()` {#testinstancefindall}
 
 ```javascript
 testInstance.findAll(test)
 ```
 
-Find all descendant test instances for which `test(testInstance)` returns `true`.
+找到所有 `test(testInstance)` 返回 `true` 的后代测试实例。
 
 ### `testInstance.findAllByType()` {#testinstancefindallbytype}
 
 ```javascript
 testInstance.findAllByType(type)
 ```
 
-Find all descendant test instances with the provided `type`.
+找到所有匹配指定 `type` 的后代测试实例。
 
 ### `testInstance.findAllByProps()` {#testinstancefindallbyprops}
 
 ```javascript
 testInstance.findAllByProps(props)
 ```
 
-Find all descendant test instances with the provided `props`.
+找到所有匹配指定 `props` 的后代测试实例。
 
 ### `testInstance.instance` {#testinstanceinstance}
 
 ```javascript
 testInstance.instance
 ```
 
-The component instance corresponding to this test instance. It is only available for class components, as function components don't have instances. It matches the `this` value inside the given component.
+该测试实例相对应的组件实例。它只能用于类定义组件，因为函数定义组件没有实例。它匹配给定的组件内部的 `this` 的值。
 
 ### `testInstance.type` {#testinstancetype}
 
 ```javascript
 testInstance.type
 ```
 
-The component type corresponding to this test instance. For example, a `<Button />` component has a type of `Button`.
+该测试实例相对应的组件的类型。例如，一个 `<Button />` 组件有一个 `Button` 类型。
 
 ### `testInstance.props` {#testinstanceprops}
 
 ```javascript
 testInstance.props
 ```
 
-The props corresponding to this test instance. For example, a `<Button size="small" />` component has `{size: 'small'}` as props.
+该测试实例相对应的组件的 props。例如，一个 `<Button size="small" />` 组件的 props 为 `{size: 'small'}`。
 
 ### `testInstance.parent` {#testinstanceparent}
 
 ```javascript
 testInstance.parent
 ```
 
-The parent test instance of this test instance.
+该测试实例的父测试实例。
 
 ### `testInstance.children` {#testinstancechildren}
 
 ```javascript
 testInstance.children
 ```
 
-The children test instances of this test instance.
+该测试实例的子测试实例。
 
-## Ideas {#ideas}
+## 意见 {#ideas}
 
-You can pass `createNodeMock` function to `TestRenderer.create` as the option, which allows for custom mock refs.
-`createNodeMock` accepts the current element and should return a mock ref object.
-This is useful when you test a component that relies on refs.
+你可以把 `createNodeMock` 函数作为选项（option）传递给 `TestRenderer.create`，可以自行模拟 refs。`createNodeMock` 接受当前元素作为参数，并且返回一个模拟 ref 对象的。这十分有利于测试依赖于 refs 的组件。
 
 ```javascript
 import TestRenderer from 'react-test-renderer';
@@ -268,7 +266,7 @@ TestRenderer.create(
   {
     createNodeMock: (element) => {
       if (element.type === 'input') {
-        // mock a focus function
+        // 模拟 focus 函数
         return {
           focus: () => {
             focused = true;