#
msgid ""
msgstr ""
"Project-Id-Version: pycsw 2.0-dev\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2018-12-05 22:08+0800\n"
"PO-Revision-Date: 2018-12-05 11:33+0800\n"
"Last-Translator: \n"
"Language: zh\n"
"Language-Team: \n"
"Plural-Forms: nplurals=1; plural=0\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.6.0\n"

#: ../../testing.rst:4
msgid "Testing"
msgstr "测试"

#: ../../testing.rst:6
msgid ""
"Pycsw uses `pytest`_ for managing its automated tests. There are a number"
" of test suites that perform mostly functional testing. These tests "
"ensure that pycsw is compliant with the various supported standards. "
"There is also a growing set of unit tests. These focus on smaller scope "
"testing, in order to verify that individual bits of code are working as "
"expected."
msgstr ""
"Pycsw使用 `pytest`_ "
"管理它的自动化测试。有许多测试套件主要执行功能测试。这些测试确保pycsw符合各种受支持的标准。"
"还有一组不断增长的单元测试。这些测试集中在较小的范围内，以便验证各个代码位是否按预期工作."

#: ../../testing.rst:13
msgid ""
"Tests can be run locally as part of the development cycle. They are also "
"run on pycsw's `Travis`_ continuous integration server against all pushes"
" and pull requests to the code repository."
msgstr ""
"测试可以作为开发周期的一部分在本地运行。它们还运行在pycsw的 `Travis`_ continuous "
"integration服务器上，用于处理所有对代码存储库的推拉请求."

#: ../../testing.rst:21
msgid "OGC CITE"
msgstr "OGC引用"

#: ../../testing.rst:23
msgid ""
"In addition to pycsw's own tests, all public releases are also tested via"
" the OGC `Compliance & Interoperability Testing & Evaluation Initiative`_"
" (CITE). The pycsw `wiki`_ documents CITE testing procedures and status."
msgstr ""
"除了pycsw自己的测试，所有的公共版本也通过OGC的 `Compliance & Interoperability Testing & Evaluation Initiative`_ (CITE)进行测试。"
"pycsw `wiki`_ 文档CITE 引用了测试过程和状态."

#: ../../testing.rst:29
msgid "Functional test suites"
msgstr "功能测试套件"

#: ../../testing.rst:31
msgid ""
"Currently most of pycsw's tests are `functional tests`_. This means that "
"each test case is based on the requirements mandated by the "
"specifications of the various standards that pycsw implements. These "
"tests focus on making sure that pycsw works as expected."
msgstr ""
"目前大多数pycsw的测试都是 `functional tests`_ 。"
"这意味着每个测试用例都基于pycsw实现的各种标准的规范所规定的需求。这些测试的重点是确保 pycsw按预期的那样工作."

#: ../../testing.rst:36
msgid "Each test follows the same workflow:"
msgstr "每个测试遵循相同的工作流程:"

#: ../../testing.rst:38
msgid ""
"Create a new pycsw instance with a custom configuration and data "
"repository for each suite of tests;"
msgstr "为每个测试套件创建一个新的pycsw实例，该实例具有自定义配置和数据存储库;"

#: ../../testing.rst:41
msgid "Perform a series of GET and POST requests to the running pycsw instance;"
msgstr "对运行的pycsw 实例执行一系列GET和POST请求;"

#: ../../testing.rst:43
msgid ""
"Compare the results of each request against a previously prepared "
"expected result. If the test result matches the expected outcome the test"
" passes, otherwise it fails."
msgstr "将每个请求的结果与预先准备的预期结果进行比较。如果测试结果与预期结果一致，则测试通过，否则失败."

#: ../../testing.rst:48
msgid ""
"A number of different test suites exist under "
"``tests/functionaltests/suites``. Each suite specifies the following "
"structure:"
msgstr "在 ``tests/functionaltests/suites`` 下存在许多不同的测试套件。每个套件指定以下结构:"

#: ../../testing.rst:51
msgid ""
"A mandatory ``default.cfg`` file with the pycsw configuration that must "
"be used by the test suite;"
msgstr "必须由测试套件使用的具有pycsw配置的强制 ``default.cfg`` ; "

#: ../../testing.rst:54
msgid ""
"A mandatory ``expected/`` directory containing the expected results for "
"each request;"
msgstr "包含每个请求的预期结果的强制性 ``expected/`` 目录;"

#: ../../testing.rst:57
msgid ""
"An optional ``data/`` directory that contains ``.xml`` files with testing"
" data that is to be loaded into the suite's database before running the "
"tests. The presence of this directory and its contents have the following"
" meaning for tests:"
msgstr ""
"一个可选的 ``data/`` 目录，包含 ``.xml`` "
"文件，其中包含要在运行测试之前加载到套件数据库中的测试数据。该目录及其内容的存在对测试具有以下意义:"

#: ../../testing.rst:62
msgid ""
"If ``data/`` directory is present and contains files, they will be loaded"
" into a new database for running the tests of the suite;"
msgstr "如果 ``data/`` 目录存在并且包含文件，它们将被加载到一个新的数据库中，用于运行套件的测试;"

#: ../../testing.rst:65
msgid ""
"If ``data/`` directory is present and does not contain any data files, a "
"new empty database is used in the tests;"
msgstr "如果存在 ``data/`` 目录并且不包含任何数据文件，则在测试中使用新的空数据库;"

#: ../../testing.rst:68
msgid ""
"If ``data/`` directory is absent, the suite will use a database populated"
" with test data from the ``CITE`` suite."
msgstr "如果 ``data/`` 目录不存在，套件将使用填充有 ``CITE`` 套件的测试数据的数据库."

#: ../../testing.rst:71
msgid ""
"An optional ``get/requests.txt`` file that holds request parameters used "
"for making HTTP GET requests."
msgstr "一个可选的 ``get/requests.txt`` 文件，其中保存用于生成HTTP GET请求的请求参数."

#: ../../testing.rst:74
msgid "Each line in the file must be formatted with the following scheme:"
msgstr "文件中的每一行必须用以下方案格式化:"

#: ../../testing.rst:76
msgid "test_id,request_query_string"
msgstr ""

#: ../../testing.rst:78 ../../testing.rst:96
msgid "For example:"
msgstr "例如："

#: ../../testing.rst:80
msgid "TestGetCapabilities,service=CSW&version=2.0.2&request=GetCapabilities"
msgstr ""

#: ../../testing.rst:82
msgid ""
"When tests are run, the *test_id* is used for naming each test and for "
"finding the expected result."
msgstr "当测试运行时， *test_id* 用于命名每个测试并寻找预期结果."

#: ../../testing.rst:85
msgid ""
"An optional ``post/`` directory that holds ``.xml`` files used for making"
" HTTP POST requests"
msgstr "一个可选的 ``post/`` 目录，它包含用于制作HTTP POST请求的 ``.xml`` 文件"

#: ../../testing.rst:90
msgid "Test identifiers"
msgstr "测试标识符"

#: ../../testing.rst:92
msgid "Each test has an identifier that is built using the following rule:"
msgstr "每个测试都有一个标识符，该标识符是使用以下规则构建的:"

#: ../../testing.rst:94
msgid "<test_function>[<suite_name>_<http_method>_<test_name>]"
msgstr ""

#: ../../testing.rst:98
msgid "test_suites[default_post_GetRecords-end]"
msgstr ""

#: ../../testing.rst:102
#, fuzzy
msgid "Functional tests' implementation"
msgstr "功能测试的实现"

#: ../../testing.rst:104
msgid ""
"Functional tests are generated for each suite directory present under "
"`tests/functionaltests/suites`. Test generation uses pytest's "
"`pytest_generate_tests`_ function. This function is implemented in "
"`tests/functionaltests/conftest.py`. It provides an automatic "
"parametrization of the "
"`tests/functionaltests/test_suites_functional:test_suites` function. This"
" parametrization causes the generation of a test for each of the GET and "
"POST requests defined in a suite's directory."
msgstr ""
"对 `tests/functionaltests/suites` 下出现的每个套件目录生成功能测试。测试生成使用pytest's "
"`pytest_generate_tests`_ 功能。这个功能在 `tests/functionaltests/conftest.py` "
"中实现。它提供了 `tests/functionaltests/test_suites_functional:test_suites` "
"功能的自动参数化。此参数化导致为套件目录中定义的每个 GET 和 POST 请求生成测试."

#: ../../testing.rst:114
msgid "Adding New Tests"
msgstr "添加新测试"

#: ../../testing.rst:116
msgid "To add tests to an existing suite:"
msgstr "在现有套件中添加测试："

#: ../../testing.rst:118
msgid ""
"for HTTP POST tests, add XML documents to "
"``tests/functionaltests/suites/<suite>/post``"
msgstr "对于HTTP POST测试，在 ``tests/functionaltests/suites/<suite>/post`` 添加XML文档"

#: ../../testing.rst:120
msgid ""
"for HTTP GET tests, add tests (one per line) to "
"``tests/functionaltests/suites/<suite>/get/requests.txt``"
msgstr ""
"对于HTTP GET测试，在 ``tests/functionaltests/suites/<suite>/get/requests.txt`` "
"中添加测试（每行的第一项）"

#: ../../testing.rst:123
msgid "To add a new test suite:"
msgstr "添加新的测试套件："

#: ../../testing.rst:125
msgid ""
"Create a new directory under ``tests/functionaltests/suites`` (e.g. "
"``foo``)"
msgstr "在 ``tests/functionaltests/suites`` （如 ``foo`` )下创建一个新目录"

#: ../../testing.rst:126
msgid "Create a new configuration in ``tests/suites/foo/default.cfg``"
msgstr "在 ``tests/suites/foo/default.cfg`` 创建一个新的配置"

#: ../../testing.rst:127
msgid "Populate HTTP POST requests in ``tests/suites/foo/post``"
msgstr "在 ``tests/suites/foo/post`` 填写HTTP POST请求"

#: ../../testing.rst:128
msgid "Populate HTTP GET requests in ``tests/suites/foo/get/requests.txt``"
msgstr "在 ``tests/suites/foo/get/requests.txt`` 填写HTTP GET请求"

#: ../../testing.rst:129
msgid ""
"If the test suite requires test data, create ``tests/suites/foo/data`` "
"and store XML files there. These will be inserted in the test catalogue "
"at test runtime"
msgstr "如果需要测试组件的测试数据，创建 ``tests/suites/foo/data``，以存储XML文件。这会在运行时插入到测试目录"

#: ../../testing.rst:132
msgid "Use pytest or tox as described above in order to run the tests"
msgstr "使用如上所述的pytest或者 tox来运行测试"

#: ../../testing.rst:134
msgid ""
"The new test suite database will be created automatically and used as "
"part of tests."
msgstr "新的测试套件数据库将自动创建，并且会成为测试的一部分。"

#: ../../testing.rst:139
msgid "Unit tests"
msgstr "单元测试"

#: ../../testing.rst:141
msgid ""
"pycsw also features unit tests. These deal with testing the expected "
"behaviour of individual functions."
msgstr "pycsw还具有单元测试。这些用于处理测试单个功能的预期行为."

#: ../../testing.rst:144
msgid ""
"The usual implementation of unit tests is to import the function/method "
"under test, run it with a set of known arguments and assert that the "
"result matches the expected outcome."
msgstr "单元测试的通常实现是导入被测试的功能/方法，用一组已知的参数运行它，并断言结果与预期结果匹配."

#: ../../testing.rst:148
msgid "Unit tests are defined in `pycsw/tests/unittests/<module_name>`."
msgstr "Unit tests are defined in  `pycsw/tests/unittests/<module_name>`."

#: ../../testing.rst:150
msgid ""
"pycsw's unit tests are marked with the `unit` marker. This makes it easy "
"to run them in isolation:"
msgstr "pycsw的单元测试用 `unit` 来标记。这使得它们很容易单独运行:"

#: ../../testing.rst:161
msgid "Running tests"
msgstr "运行测试"

#: ../../testing.rst:163
msgid ""
"Since pycsw uses `pytest`_, tests are run with the ``py.test`` runner. A "
"basic test run can be made with:"
msgstr "由于pycsw使用 `pytest`_，所以测试是用 ``py.test`` runner运行的。一个基本的测试运行可以用："

#: ../../testing.rst:170
msgid ""
"This command will run all tests and report on the number of successes, "
"failures and also the time it took to run them. The `py.test` command "
"accepts several additional parameters that can be used in order to "
"customize the execution of tests. Look into `pytest's invocation "
"documentation`_ for a more complete description. You can also get a "
"description of the available parameters by running:"
msgstr ""
"这个命令将运行所有测试，并报告成功、失败次数以及运行它们所花费的时间。 `py.test` "
"命令接受几个额外的参数，这些参数可用于自定义测试的执行。查看 `pytest's invocation "
"documentation`_，以获得更完整的描述。您还可以通过运行来获得可用参数的描述："

#: ../../testing.rst:183
msgid "Running specific suites and test cases"
msgstr "运行特定套件和测试用例"

#: ../../testing.rst:185
msgid ""
"py.test allows tagging tests with markers. These can be used to "
"selectively run some tests. pycsw uses two markers:"
msgstr "py.test 允许标记测试。这些可以用来选择性地运行一些测试。 pycsw 使用两个标记："

#: ../../testing.rst:188
msgid "``unit`` - run only inut tests"
msgstr "``unit`` - 只运行inut测试"

#: ../../testing.rst:189
msgid "``functional``- run onyl functional tests"
msgstr "``functional``- 只运行功能测试"

#: ../../testing.rst:191
msgid "Markers can be specified by using the ``-m <marker_name>`` flag."
msgstr "标记可以通过使用 ``-m <marker_name>`` 标志来指定."

#: ../../testing.rst:197
msgid ""
"You can also use the ``-k <name_expression>`` flag to select which tests "
"to run. Since each test's name includes the suite name, http method and "
"an identifier for the test, it is easy to run only certain tests."
msgstr ""
"您还可以使用 ``-k <name_expression>`` "
"标志来选择要运行哪些测试。由于每个测试的名称都包含套件名称、http方法和测试的标识符，因此仅运行某些测试很容易."

#: ../../testing.rst:208
msgid "The ``-m`` and ``-k`` flags can be combined."
msgstr "``-m`` and ``-k`` 标志可以组合起来."

#: ../../testing.rst:212
msgid "Exiting fast"
msgstr "快速退出"

#: ../../testing.rst:214
msgid ""
"The ``--exitfirst`` (or ``-x``) flag can be used to stop the test runner "
"immediately as soon as a test case fails."
msgstr "``--exitfirst`` (or ``-x`` ) 标志可用于在测试用例失败时立即停止测试运行程序."

#: ../../testing.rst:223
msgid "Seeing more output"
msgstr "看到更多的输出"

#: ../../testing.rst:225
msgid "There are three main ways to get more output from running tests:"
msgstr "从运行测试中获得更多输出的主要方法有三种:"

#: ../../testing.rst:227
msgid "The ``--verbose`` (or ``-v``) flag;"
msgstr "``--verbose`` (or ``-v`` ) 标志;"

#: ../../testing.rst:229
msgid ""
"The ``--capture=no`` flag - Messages sent to stdout by a test are not "
"suppressed;"
msgstr "测试发送到stdout的 ``--capture=no``  flag - Messages不会被抑制;"

#: ../../testing.rst:232
msgid ""
"The ``--pycsw-loglevel`` flag - Sets the log level of the pycsw instance "
"under test. Set this value to ``debug`` in order to see all debug "
"messages sent by pycsw while processing a request."
msgstr ""
"``--pycsw-loglevel`` 标志 - 设置被测试的pycsw实例的日志级别。将此值设置为 ``debug`` "
"，以便查看pycsw在处理请求时发送的所有调试消息."

#: ../../testing.rst:245
msgid "Comparing results with difflib instead of XML c14n"
msgstr "将结果与difflib而不是XML c14n进行比较"

#: ../../testing.rst:247
msgid ""
"The functional tests compare results with their expected values by using "
"[XML canonicalisation - XML c14n](https://www.w3.org/TR/xml-c14n/). "
"Alternatively, you can call py.test with the ``--functional-prefer-"
"diffs`` flag. This will enable comparison based on Python's ``difflib``. "
"Comparison is made on a line-by-line basis and in case of failure, a "
"unified diff will be printed to standard output."
msgstr ""
"功能测试使用 [XML canonicalisation - XML c14n](https://www.w3.org/TR/xml-c14n/)"
" 将结果与期望值进行比较。或者，也可以调用py, 使用 ``--functional-prefer-diffs`` 标志进行测试。这将支持基于 "
"Python's ``difflib`` 的比较。在逐行比较的基础上，如果失败,将把统一的差异打印到标准输出."

#: ../../testing.rst:260
msgid "Saving test results for disk"
msgstr "在磁盘中保存测试结果"

#: ../../testing.rst:262
msgid ""
"The result of each functional test can be saved to disk by using the "
"``--functional-save-results-directory`` option. Each result file is named"
" after the test identifier it has when running with pytest."
msgstr ""
"通过使用 ``--functional-save-results-directory`` "
"选项，可以将每个功能测试的结果保存到磁盘上。每个结果文件都是根据使用pytest运行时的测试标识符命名的."

#: ../../testing.rst:273
msgid "Test coverage"
msgstr "测试覆盖率"

#: ../../testing.rst:275
msgid ""
"Use the `--cov pycsw` flag in order to see information on code coverage. "
"It is possible to get output in a variety of formats."
msgstr "使用 `--cov pycsw` 标志来查看代码覆盖率的信息。可以以各种格式获得输出."

#: ../../testing.rst:284
msgid "Specifying a timeout for tests"
msgstr "指定测试超时"

#: ../../testing.rst:286
msgid ""
"The `--timeout <seconds>` option can be used to specify that if a test "
"takes more than `<seconds>` to run it is considered to have failed. "
"Seconds can be a float, so it is possibe to specify sub-second timeouts"
msgstr ""
"`--timeout <seconds>` 选项可用于指定如果测试运行时间超过 "
"`<seconds>`，则认为它已经失败。秒可以是一个浮点，所以可以指定次秒超时"

#: ../../testing.rst:296
msgid "Linting with flake8"
msgstr "Linting with flake8"

#: ../../testing.rst:298
msgid ""
"Use the `--flake8` flag to also check if the code complies with Python's "
"style guide"
msgstr "使用 `--flake8` 标志也检查代码是否符合Python风格指南"

#: ../../testing.rst:307
msgid "Testing multiple Python versions"
msgstr "测试多个Python版本"

#: ../../testing.rst:309
msgid ""
"For testing multiple Python versions and configurations simultaneously "
"you can use `tox`_. pycsw includes a `tox.ini` file with a suitable "
"configuration. It can be used to run tests against multiple Python "
"versions and also multiple database backends. When running `tox` you can "
"send arguments to the `py.test` runner by using the invocation `tox <tox "
"arguments> -- <py.test arguments>`. Examples:"
msgstr ""
"为了同时测试多个Python版本和配置，可以使用 `tox`_ 。 pycsw包含一个具有适当配置的 `tox.ini` "
"文件它可以用于对多个Python版本和多个数据库后端进行测试。在运行 `tox` 时，"
"可以通过调用 `tox <tox arguments> -- <py.test arguments>` 向 `py.test` 运行程序发送参数。例如："

#: ../../testing.rst:333
msgid "Web Testing"
msgstr "Web测试"

#: ../../testing.rst:335
msgid ""
"You can also use the pycsw tests via your web browser to perform sample "
"requests against your pycsw install.  The tests are is located in "
"``tests/``.  To generate the HTML page:"
msgstr "您还可以通过Web浏览器使用pycsw测试，来执行你的pycsw安装样例申请。这些测试在 ``tests/`` 中。生成HTML页面："

#: ../../testing.rst:343
msgid "Then navigate to ``http://host/path/to/pycsw/tests/index.html``."
msgstr "然后导航到 ``http://host/path/to/pycsw/tests/index.html`` 。"

#~ msgid ""
#~ "Compliance benchmarking is done via the"
#~ " OGC `Compliance & Interoperability Testing"
#~ " & Evaluation Initiative`_.  The pycsw "
#~ "`wiki <https://github.com/geopython/pycsw/wiki/OGC-"
#~ "CITE-Compliance>`_ documents testing procedures"
#~ " and status."
#~ msgstr ""
#~ "合规性基准是通过OGC `合规性和互操作性测试与自发性评估`_ 完成的。该pycsw维基 "
#~ "`<https://github.com/geopython/pycsw/wiki/OGC-CITE-"
#~ "Compliance>`_ 文档测试程序和状态。"

#~ msgid "Tester"
#~ msgstr "测试仪"

#~ msgid ""
#~ "The pycsw tests framework (in ``tests``)"
#~ " is a collection of testsuites to "
#~ "perform automated regession testing of "
#~ "the codebase.  Test are run against "
#~ "all pushes to the GitHub repository "
#~ "via `Travis CI`_."
#~ msgstr ""
#~ "该pycsw测试框架（在 ``tests`` 里）是测试包的集合体，用来执行代码库的自动regession测试。通过"
#~ " `Travis CI`_ ，测试在GitHub的库中运行。"

#~ msgid "Running Locally"
#~ msgstr "本地运行"

#~ msgid ""
#~ "The tests framework can be run "
#~ "from ``tests`` using `Paver`_ (see "
#~ "``pavement.py``) tasks for convenience:"
#~ msgstr "为方便工作，测试框架可以用 `Paver`_ (见 ``pavement.py``) 在 ``tests`` 中运行："

#~ msgid ""
#~ "The tests perform HTTP GET and "
#~ "POST requests against ``http://localhost:8000``."
#~ "  The expected output for each test"
#~ " can be found in ``expected``.  "
#~ "Results are categorized as ``passed``, "
#~ "``failed``, or ``initialized``.  A summary "
#~ "of results is output at the end"
#~ " of the run."
#~ msgstr ""
#~ "针对 ``http://localhost:8000``，测试执行HTTP "
#~ "GET和POST请求。每个测试的输出都在``expected``中。结果被归类为``通过``，``失败``，或``初始化``。总结的结果会在运行结束时输出。"

#~ msgid "Failed Tests"
#~ msgstr "测试失败"

#~ msgid ""
#~ "If a given test has failed, the"
#~ " output is saved in ``results``.  The"
#~ " resulting failure can be analyzed by"
#~ " running ``diff tests/expected/name_of_test.xml "
#~ "tests/results/name_of_test.xml`` to find variances."
#~ "  The Paver task returns a status "
#~ "code which indicates the number of "
#~ "tests which have failed (i.e. ``echo "
#~ "$?``)."
#~ msgstr ""
#~ "如果某个测试失败，输出将保存在``结果``中。 运行``diff "
#~ "tests/expected/name_of_test.xml tests/results/name_of_test.xml``"
#~ " ，会自动统计失败结果以找到差异。Paver任务会返回一个状态代码，表示已失败的测试数目（即``echo $?``）。"

#~ msgid "Test Suites"
#~ msgstr "测试套件"

#~ msgid ""
#~ "The tests framework is run against "
#~ "a series of 'suites' (in "
#~ "``tests/suites``), each of which specifies "
#~ "a given configuration to test various"
#~ " functionality of the codebase.  Each "
#~ "suite is structured as follows:"
#~ msgstr ""
#~ "测试框架将针对一系列“套件”（在``测试/ "
#~ "suites``）完成运行，其中每一项均指定一个给定的配置，以测试基本代码的各种功能。每个套件的结构如下："

#~ msgid "``tests/suites/suite/default.cfg``: the configuration for the suite"
#~ msgstr "`tests/suites/suite/default.cfg`：对于该套件的配置"

#~ msgid ""
#~ "``tests/suites/suite/post``: directory of XML "
#~ "documents for HTTP POST requests"
#~ msgstr "`tests/suites/suite/post`：XML文档目录的HTTP POST请求"

#~ msgid ""
#~ "``tests/suites/suite/get/requests.txt``: directory and "
#~ "text file of KVP for HTTP GET "
#~ "requests"
#~ msgstr "`tests/suites/suite/get/requests.txt`：KVP的目录和文本文件，用于HTTP GET请求"

#~ msgid ""
#~ "``tests/suites/suite/data``: directory of sample "
#~ "XML data required for the test "
#~ "suite.  Database and test data are "
#~ "setup/loaded automatically as part of "
#~ "testing"
#~ msgstr "`tests/suites/suite/data`：测试套件所需样本的XML数据目录。作为测试的一部分，数据库和测试数据是自动设置或自动加载的"

#~ msgid "When the tests are invoked, the following operations are run:"
#~ msgstr "当测试被调用，将执行以下操作："

#~ msgid "pycsw configuration is set to ``tests/suites/suite/default.cfg``"
#~ msgstr "pycsw配置设置为`tests/suites/suite/default.cfg`"

#~ msgid "HTTP POST requests are run against ``tests/suites/suite/post/*.xml``"
#~ msgstr "HTTP POST请求是针对 `tests/suites/suite/post/*.xml` 运行的"

#~ msgid ""
#~ "HTTP GET requests are run against "
#~ "each request in "
#~ "``tests/suites/suite/get/requests.txt``"
#~ msgstr "HTTP GET请求是针对 ``tests/suites/suite/get/requests.txt`` 运行的"

#~ msgid ""
#~ "The CSV format of "
#~ "``tests/suites/suite/get/requests.txt`` is "
#~ "``testname,request``, with one line for "
#~ "each test.  The ``testname`` value is"
#~ " a unique test name (this value "
#~ "sets the name of the output file"
#~ " in the test results).  The "
#~ "``request`` value is the HTTP GET "
#~ "request.  The ``PYCSW_SERVER`` token is "
#~ "replaced at runtime with the URL "
#~ "to the pycsw install."
#~ msgstr ""
#~ "在每项测试的第一行中， `tests/suites/suite/get/requests.txt` 的CSV格式是"
#~ "  `testname,request` 。该 ``testname`` "
#~ "值是唯一的测试名（此值设置在测试结果输出文件的名称内）。该 ``request`` 值是HTTP "
#~ "GET请求的值。该 ``PYCSW_SERVER`` 在URL pycsw安装运行时会被替换掉的。"

#~ msgid "run ``paver test``"
#~ msgstr "运行`paver test`"

#~ msgid "Ensure that all file paths are relative to ``path/to/pycsw``"
#~ msgstr "确保所有文件的路径都关联 ``path/to/pycsw`` "

#~ msgid ""
#~ "Ensure that ``repository.database`` points to"
#~ " an SQLite3 database called "
#~ "``tests/suites/foo/data/records.db``.  The database "
#~ "*must* be called ``records.db`` and the"
#~ " directory ``tests/suites/foo/data`` *must* exist"
#~ msgstr ""
#~ "确保 ``repository.database`` 指定于 "
#~ "``tests/suites/foo/data/records.db`` 的一个sqlite3数据库。该数据库*必须*被写为"
#~ " ``records.db``，目录 ``tests/suites/foo/data`` 也必须存在"

#~ msgid ""
#~ "run ``paver test`` (or ``paver test "
#~ "-s foo`` to test only the new "
#~ "test suite)"
#~ msgstr "运行 ``paver test`` （或 ``paver test-s foo`` ， 仅用来测试新的测试套件）"

