Showing preview only (1,128K chars total). Download the full file or copy to clipboard to get everything.
Repository: Manwe56/competitive-programming
Branch: master
Commit: 4f92a09592b8
Files: 105
Total size: 27.2 MB
Directory structure:
gitextract_u9fmdbai/
├── .classpath
├── .gitignore
├── .project
├── .travis.yml
├── LICENSE
├── README.md
├── build.gradle
├── docs/
│ └── DEVOXX_2017_De_bronze_a_legendaire_comment_reussir_vos_IA_de_Bot.pptx
├── libs/
│ └── googleTest/
│ └── 1.7.0/
│ ├── include/
│ │ └── gtest/
│ │ ├── gtest-death-test.h
│ │ ├── gtest-message.h
│ │ ├── gtest-param-test.h
│ │ ├── gtest-param-test.h.pump
│ │ ├── gtest-printers.h
│ │ ├── gtest-spi.h
│ │ ├── gtest-test-part.h
│ │ ├── gtest-typed-test.h
│ │ ├── gtest.h
│ │ ├── gtest_pred_impl.h
│ │ ├── gtest_prod.h
│ │ └── internal/
│ │ ├── gtest-death-test-internal.h
│ │ ├── gtest-filepath.h
│ │ ├── gtest-internal.h
│ │ ├── gtest-linked_ptr.h
│ │ ├── gtest-param-util-generated.h
│ │ ├── gtest-param-util-generated.h.pump
│ │ ├── gtest-param-util.h
│ │ ├── gtest-port.h
│ │ ├── gtest-string.h
│ │ ├── gtest-tuple.h
│ │ ├── gtest-tuple.h.pump
│ │ ├── gtest-type-util.h
│ │ └── gtest-type-util.h.pump
│ └── lib/
│ ├── cygwin/
│ │ └── gtest.lib
│ ├── linux/
│ │ └── libgtest.a
│ ├── mingw/
│ │ └── gtest.lib
│ ├── osx/
│ │ └── libgtest.a
│ ├── vs2010/
│ │ └── gtest.lib
│ ├── vs2013/
│ │ └── gtest.lib
│ └── vs2015/
│ └── gtest.lib
├── settings.gradle
└── src/
├── competitiveProgramming/
│ └── headers/
│ ├── FileBuilderSample.hpp
│ └── competitive/
│ └── programming/
│ ├── gametheory/
│ │ ├── Common.hpp
│ │ ├── TreeNode.hpp
│ │ ├── maxntree/
│ │ │ └── MaxNTree.hpp
│ │ ├── minimax/
│ │ │ └── Minimax.hpp
│ │ └── treeSearch/
│ │ └── TreeSearch.hpp
│ ├── genetic/
│ │ └── GeneticAlgorithm.hpp
│ ├── geometry/
│ │ └── Point.hpp
│ ├── graph/
│ │ └── Graph.hpp
│ ├── math/
│ │ ├── Complex.hpp
│ │ └── QuadraticEquation.hpp
│ ├── physics/
│ │ └── Disk.hpp
│ └── timemanagement/
│ └── Timer.hpp
├── competitiveProgrammingTest/
│ └── cpp/
│ ├── competitive/
│ │ └── programming/
│ │ ├── gametheory/
│ │ │ └── TreesTest.cpp
│ │ ├── genetic/
│ │ │ └── GeneticAlgorithmTest.cpp
│ │ ├── geometry/
│ │ │ └── PointTest.cpp
│ │ ├── graph/
│ │ │ └── GraphTest.cpp
│ │ ├── math/
│ │ │ └── QuadraticEquationTest.cpp
│ │ ├── physics/
│ │ │ └── DiskTest.cpp
│ │ └── timemanagement/
│ │ └── TimerTest.cpp
│ └── test_main.cpp
├── main/
│ └── java/
│ ├── builder/
│ │ ├── FileBuilder.java
│ │ └── sample/
│ │ └── Sample.java
│ └── competitive/
│ └── programming/
│ ├── common/
│ │ └── Constants.java
│ ├── containers/
│ │ └── Pair.java
│ ├── gametheory/
│ │ ├── ICancellableMove.java
│ │ ├── IGame.java
│ │ ├── IMove.java
│ │ ├── IMoveGenerator.java
│ │ ├── common/
│ │ │ ├── IScoreConverter.java
│ │ │ ├── TreeNode.java
│ │ │ └── TreeNodeSorter.java
│ │ ├── maxntree/
│ │ │ └── MaxNTree.java
│ │ ├── minimax/
│ │ │ └── Minimax.java
│ │ └── treesearch/
│ │ └── TreeSearch.java
│ ├── genetic/
│ │ ├── CandidateGenerator.java
│ │ ├── CandidateMerger.java
│ │ ├── CandidateMutator.java
│ │ ├── FitnessFunction.java
│ │ └── GeneticAlgorithm.java
│ ├── geometry/
│ │ ├── Coord.java
│ │ └── Vector.java
│ ├── graph/
│ │ ├── Graph.java
│ │ ├── IBFSTraversable.java
│ │ ├── IDoubleBfsNextLevelValueIterator.java
│ │ └── IIntegerBfsNextValueIterator.java
│ ├── math/
│ │ ├── Complex.java
│ │ └── QuadraticEquation.java
│ ├── physics/
│ │ └── Disk.java
│ └── timemanagement/
│ ├── TimeoutException.java
│ └── Timer.java
└── test/
└── java/
└── competitive/
└── programming/
├── gametheory/
│ ├── StickGame.java
│ ├── StickGenerator.java
│ ├── StickMove.java
│ ├── Tester.java
│ ├── maxntree/
│ │ └── MaxNTreeTest.java
│ ├── minimax/
│ │ └── MinimaxTest.java
│ └── treesearch/
│ └── TreeSearchTest.java
├── genetic/
│ └── GeneticAlgorithmTest.java
├── geometry/
│ ├── CoordTest.java
│ └── VectorTest.java
├── graph/
│ └── GraphTest.java
├── math/
│ └── QuadraticEquationTest.java
├── physics/
│ └── DiskTest.java
└── timemanagement/
└── TimerTest.java
================================================
FILE CONTENTS
================================================
================================================
FILE: .classpath
================================================
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src/main/java"/>
<classpathentry kind="src" path="src/test/java"/>
<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
<attributes>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
<attributes>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="output" path="target/classes"/>
</classpath>
================================================
FILE: .gitignore
================================================
/bin/
/target/
/.settings/
/vs/
/build/
/.gradle/
.idea
*.vcxproj
*.vcxproj.filters
*.iml
================================================
FILE: .project
================================================
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>competitive-programming</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.sonarlint.eclipse.core.sonarlintBuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.m2e.core.maven2Builder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.m2e.core.maven2Nature</nature>
<nature>org.eclipse.jdt.core.javanature</nature>
</natures>
</projectDescription>
================================================
FILE: .travis.yml
================================================
language: java
jdk:
- oraclejdk8
before_install:
- sudo sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
- sudo apt-get -qq update
- sudo apt-get install python-software-properties
- sudo apt-get install g++-5 gcc-5 gcc-5-multilib g++-5-multilib lib32stdc++6-5-dbg libstdc++6-5-dbg
- sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 80 --slave /usr/bin/g++ g++ /usr/bin/g++-5
- wget http://services.gradle.org/distributions/gradle-3.1-bin.zip
- unzip gradle-3.1-bin.zip
- export GRADLE_HOME=$PWD/gradle-3.1
- export PATH=$GRADLE_HOME/bin:$PATH
- gradle -v
================================================
FILE: LICENSE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "{}"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright {yyyy} {name of copyright owner}
Licensed 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.
================================================
FILE: README.md
================================================
[](https://travis-ci.org/Manwe56/competitive-programming)
# Why this project
It's been a while (2010) I race in various online programming competitions (started with google ai challenge, then mostly hackerrank and codingame) under the nickname Manwe. I am quite proud of the results: once winner, often in the top 1%, always in the top 5%.
It is a real pleasure each time and I am thrilled when a new contest is announced!
Time after time, challenges are different for sure, but I accumulated a set of tools classes and algorithms that might be helpful from a challenge to another. Of course it comes with a set of best practices I discovered over time :)
This project aims at sharing with the community those Java and C++ code I appreciate in the challenges and are helping you gain time, allowing you to develop in several files with a one click build, and sharing a common set of codes between challenges. Don't reinvent the wheel, focus on the subject!
In the docs folder you will find a pdf with advices if you launch yourself in competitive programming
Do not hesitate to contribute, fork and make pull requests!
# constraints
Those challenges are usually online and includes a code editor. If you are free to use another IDE, your code is usually in a single file that make you intensely use inner classes. To ease your work, there is a builder that allows you to build a single file class from a main class and will grab all its dependencies. You can now split your code across several files and directly build your file in a single operation. It is certainly a prerequisite to share easily some code between your different challenges
Another constraint is that you usually don't have access to any third party software, and you must use the native libraries. That's why this project is not taking advantage of third party software. The objective is really focusing on this kind of challenges instead of providing state of the art artificial intelligence library. Note also that you might have a file size limit, and in this case you should not have too much dependencies
# how to use the builder
Builder is that class in charge of building a single file from you different classes. It is writen in Java and located in the builder package. Have a look at the javadoc for more info.
THe builder supports both Java and C++ files so you can use it for both.
# hints
You will often find "Hint" sections in the comments. They are here to help you use the tools, or give you some advice you might find useful when programming for a contest. They are not documentation as is but more ideas that can make the difference.
# build and test
This project is built using gradle 3.1. This choice has been made because it is a multiple language codeline and it will build and test in a single operation both C++11 and Java 8 codes.
So to launch the compilation and then run all the unit tests in both C++ and Java, simply launch the command:
gradle check
Note: On windows, several versions of the google test lib are available and depending on which version and compiler you are using, you might want to uncomment the relevant line in the method findGoogleTestCoreLibForPlatform
# for Java developers:
Code uses the Java version 8.
## code layout
The source code is in the src/main/java folder, and the tests are in the src/test/java folder.
You will find a builder package that contains only the utilities allowing you to build your "single file" program.
The rest of the code is in the competitive.programming package and then by theme.
If you want to contribute, feel free to add contest independent code in the competitive.programming package.
I would advice you create your own package by contest when using this project so that you are not packaging several files with a main :)
## mounting the project in eclipse
I use eclipse as IDE, and the project includes directly an eclipse project.
You can also use maven to build project files for various IDE
# for C++ developers:
Code uses C++ 11.
## code layout
I wanted to have the code in the src/main/cpp folder, but encountered issues with Travis CI to build and test the codeline. So I ended up with a code layout that is completely different.
So header files could be found in the src/competitiveProgramming/headers folder and the tests are located in the src/competitiveProgrammingTest/cpp folder.
## coding conventions
Since I wanted the builder to be able to concatenate the different files in a single file without investing too much in its complexity, I took decisions that would not be valid in a real production project:
All the source code is in the header files. Include path are always from the "headers" folder. If you not respect this convention, the builder will fail to resolve your include file path and will ignore it.
================================================
FILE: build.gradle
================================================
apply plugin: 'java'
apply plugin: 'cpp'
apply plugin: 'maven'
apply plugin: 'eclipse'
apply plugin: 'google-test-test-suite'
apply plugin: "visual-studio"
group = 'competitive-programming'
version = '0.0.1-SNAPSHOT'
description = """Competitive programming"""
sourceCompatibility = 1.8
targetCompatibility = 1.8
repositories {
maven { url "http://repo.maven.apache.org/maven2" }
}
dependencies {
testCompile group: 'junit', name: 'junit', version:'4.11'
}
model {
toolChains {
gcc(Gcc) {
eachPlatform { tools ->
tools.cppCompiler.executable = "g++-5"
}
}
visualcpp(VisualCpp) {
}
}
platforms {
x86 {
architecture "x86"
}
}
repositories {
libs(PrebuiltLibraries) {
googleTest {
headers.srcDir "libs/googleTest/1.7.0/include"
binaries.withType(StaticLibraryBinary) {
staticLibraryFile =
file("libs/googleTest/1.7.0/lib/" +
findGoogleTestCoreLibForPlatform(targetPlatform))
}
}
}
}
components {
competitiveProgramming(NativeLibrarySpec) {
targetPlatform "x86"
}
}
testSuites {
competitiveProgrammingTest(GoogleTestTestSuiteSpec) {
testing $.components.competitiveProgramming
}
}
binaries {
all {
if (toolChain in VisualCpp) {
linker.args "/DEBUG"
linker.args "-Z7"
cppCompiler.args "/DEBUG"
cppCompiler.args "-Z7"
cppCompiler.args "-IC:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.10240.0\\ucrt"
linker.args "/LIBPATH:C:\\Program Files (x86)\\Windows Kits\\10\\Lib\\10.0.10240.0\\ucrt\\x86"
}
}
withType(GoogleTestTestSuiteBinarySpec) {
lib library: "googleTest", linkage: "static"
if (targetPlatform.operatingSystem.linux) {
cppCompiler.args '-pthread'
cppCompiler.args '-std=c++11'
linker.args '-std=c++11'
linker.args '-pthread'
}
}
}
visualStudio {
solutions.all {
solutionFile.location = "vs/${name}.sln"
solutionFile.withContent { TextProvider content ->
content.asBuilder().insert(0, "# GENERATED FILE: DO NOT EDIT\n")
content.text = content.text.replaceAll("HideSolutionNode = FALSE", "HideSolutionNode = TRUE")
}
}
}
}
tasks.withType(RunTestExecutable) {
args "--gtest_output=xml:test_detail.xml"
}
def findGoogleTestCoreLibForPlatform(Platform platform) {
if (platform.operatingSystem.windows) {
return "vs2015/gtest.lib"
// return "vs2013/gtest.lib"
// return "vs2013/gtest-core.lib"
// return "cygwin/gtest-core.lib"
// return "mingw/gtest-core.lib"
} else if (platform.operatingSystem.macOsX) {
return "osx/libgtest.a"
} else {
return "linux/libgtest.a"
}
}
================================================
FILE: docs/DEVOXX_2017_De_bronze_a_legendaire_comment_reussir_vos_IA_de_Bot.pptx
================================================
[File too large to display: 26.1 MB]
================================================
FILE: libs/googleTest/1.7.0/include/gtest/gtest-death-test.h
================================================
// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: wan@google.com (Zhanyong Wan)
//
// The Google C++ Testing Framework (Google Test)
//
// This header file defines the public API for death tests. It is
// #included by gtest.h so a user doesn't need to include this
// directly.
#ifndef GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
#define GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
#include "gtest/internal/gtest-death-test-internal.h"
namespace testing {
// This flag controls the style of death tests. Valid values are "threadsafe",
// meaning that the death test child process will re-execute the test binary
// from the start, running only a single death test, or "fast",
// meaning that the child process will execute the test logic immediately
// after forking.
GTEST_DECLARE_string_(death_test_style);
#if GTEST_HAS_DEATH_TEST
namespace internal {
// Returns a Boolean value indicating whether the caller is currently
// executing in the context of the death test child process. Tools such as
// Valgrind heap checkers may need this to modify their behavior in death
// tests. IMPORTANT: This is an internal utility. Using it may break the
// implementation of death tests. User code MUST NOT use it.
GTEST_API_ bool InDeathTestChild();
} // namespace internal
// The following macros are useful for writing death tests.
// Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is
// executed:
//
// 1. It generates a warning if there is more than one active
// thread. This is because it's safe to fork() or clone() only
// when there is a single thread.
//
// 2. The parent process clone()s a sub-process and runs the death
// test in it; the sub-process exits with code 0 at the end of the
// death test, if it hasn't exited already.
//
// 3. The parent process waits for the sub-process to terminate.
//
// 4. The parent process checks the exit code and error message of
// the sub-process.
//
// Examples:
//
// ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number");
// for (int i = 0; i < 5; i++) {
// EXPECT_DEATH(server.ProcessRequest(i),
// "Invalid request .* in ProcessRequest()")
// << "Failed to die on request " << i;
// }
//
// ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting");
//
// bool KilledBySIGHUP(int exit_code) {
// return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP;
// }
//
// ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!");
//
// On the regular expressions used in death tests:
//
// On POSIX-compliant systems (*nix), we use the <regex.h> library,
// which uses the POSIX extended regex syntax.
//
// On other platforms (e.g. Windows), we only support a simple regex
// syntax implemented as part of Google Test. This limited
// implementation should be enough most of the time when writing
// death tests; though it lacks many features you can find in PCRE
// or POSIX extended regex syntax. For example, we don't support
// union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and
// repetition count ("x{5,7}"), among others.
//
// Below is the syntax that we do support. We chose it to be a
// subset of both PCRE and POSIX extended regex, so it's easy to
// learn wherever you come from. In the following: 'A' denotes a
// literal character, period (.), or a single \\ escape sequence;
// 'x' and 'y' denote regular expressions; 'm' and 'n' are for
// natural numbers.
//
// c matches any literal character c
// \\d matches any decimal digit
// \\D matches any character that's not a decimal digit
// \\f matches \f
// \\n matches \n
// \\r matches \r
// \\s matches any ASCII whitespace, including \n
// \\S matches any character that's not a whitespace
// \\t matches \t
// \\v matches \v
// \\w matches any letter, _, or decimal digit
// \\W matches any character that \\w doesn't match
// \\c matches any literal character c, which must be a punctuation
// . matches any single character except \n
// A? matches 0 or 1 occurrences of A
// A* matches 0 or many occurrences of A
// A+ matches 1 or many occurrences of A
// ^ matches the beginning of a string (not that of each line)
// $ matches the end of a string (not that of each line)
// xy matches x followed by y
//
// If you accidentally use PCRE or POSIX extended regex features
// not implemented by us, you will get a run-time failure. In that
// case, please try to rewrite your regular expression within the
// above syntax.
//
// This implementation is *not* meant to be as highly tuned or robust
// as a compiled regex library, but should perform well enough for a
// death test, which already incurs significant overhead by launching
// a child process.
//
// Known caveats:
//
// A "threadsafe" style death test obtains the path to the test
// program from argv[0] and re-executes it in the sub-process. For
// simplicity, the current implementation doesn't search the PATH
// when launching the sub-process. This means that the user must
// invoke the test program via a path that contains at least one
// path separator (e.g. path/to/foo_test and
// /absolute/path/to/bar_test are fine, but foo_test is not). This
// is rarely a problem as people usually don't put the test binary
// directory in PATH.
//
// TODO(wan@google.com): make thread-safe death tests search the PATH.
// Asserts that a given statement causes the program to exit, with an
// integer exit status that satisfies predicate, and emitting error output
// that matches regex.
# define ASSERT_EXIT(statement, predicate, regex) \
GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_)
// Like ASSERT_EXIT, but continues on to successive tests in the
// test case, if any:
# define EXPECT_EXIT(statement, predicate, regex) \
GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_NONFATAL_FAILURE_)
// Asserts that a given statement causes the program to exit, either by
// explicitly exiting with a nonzero exit code or being killed by a
// signal, and emitting error output that matches regex.
# define ASSERT_DEATH(statement, regex) \
ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
// Like ASSERT_DEATH, but continues on to successive tests in the
// test case, if any:
# define EXPECT_DEATH(statement, regex) \
EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
// Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*:
// Tests that an exit code describes a normal exit with a given exit code.
class GTEST_API_ ExitedWithCode {
public:
explicit ExitedWithCode(int exit_code);
bool operator()(int exit_status) const;
private:
// No implementation - assignment is unsupported.
void operator=(const ExitedWithCode& other);
const int exit_code_;
};
# if !GTEST_OS_WINDOWS
// Tests that an exit code describes an exit due to termination by a
// given signal.
class GTEST_API_ KilledBySignal {
public:
explicit KilledBySignal(int signum);
bool operator()(int exit_status) const;
private:
const int signum_;
};
# endif // !GTEST_OS_WINDOWS
// EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode.
// The death testing framework causes this to have interesting semantics,
// since the sideeffects of the call are only visible in opt mode, and not
// in debug mode.
//
// In practice, this can be used to test functions that utilize the
// LOG(DFATAL) macro using the following style:
//
// int DieInDebugOr12(int* sideeffect) {
// if (sideeffect) {
// *sideeffect = 12;
// }
// LOG(DFATAL) << "death";
// return 12;
// }
//
// TEST(TestCase, TestDieOr12WorksInDgbAndOpt) {
// int sideeffect = 0;
// // Only asserts in dbg.
// EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death");
//
// #ifdef NDEBUG
// // opt-mode has sideeffect visible.
// EXPECT_EQ(12, sideeffect);
// #else
// // dbg-mode no visible sideeffect.
// EXPECT_EQ(0, sideeffect);
// #endif
// }
//
// This will assert that DieInDebugReturn12InOpt() crashes in debug
// mode, usually due to a DCHECK or LOG(DFATAL), but returns the
// appropriate fallback value (12 in this case) in opt mode. If you
// need to test that a function has appropriate side-effects in opt
// mode, include assertions against the side-effects. A general
// pattern for this is:
//
// EXPECT_DEBUG_DEATH({
// // Side-effects here will have an effect after this statement in
// // opt mode, but none in debug mode.
// EXPECT_EQ(12, DieInDebugOr12(&sideeffect));
// }, "death");
//
# ifdef NDEBUG
# define EXPECT_DEBUG_DEATH(statement, regex) \
GTEST_EXECUTE_STATEMENT_(statement, regex)
# define ASSERT_DEBUG_DEATH(statement, regex) \
GTEST_EXECUTE_STATEMENT_(statement, regex)
# else
# define EXPECT_DEBUG_DEATH(statement, regex) \
EXPECT_DEATH(statement, regex)
# define ASSERT_DEBUG_DEATH(statement, regex) \
ASSERT_DEATH(statement, regex)
# endif // NDEBUG for EXPECT_DEBUG_DEATH
#endif // GTEST_HAS_DEATH_TEST
// EXPECT_DEATH_IF_SUPPORTED(statement, regex) and
// ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if
// death tests are supported; otherwise they just issue a warning. This is
// useful when you are combining death test assertions with normal test
// assertions in one test.
#if GTEST_HAS_DEATH_TEST
# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
EXPECT_DEATH(statement, regex)
# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
ASSERT_DEATH(statement, regex)
#else
# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, )
# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, return)
#endif
} // namespace testing
#endif // GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
================================================
FILE: libs/googleTest/1.7.0/include/gtest/gtest-message.h
================================================
// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: wan@google.com (Zhanyong Wan)
//
// The Google C++ Testing Framework (Google Test)
//
// This header file defines the Message class.
//
// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
// leave some internal implementation details in this header file.
// They are clearly marked by comments like this:
//
// // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
//
// Such code is NOT meant to be used by a user directly, and is subject
// to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user
// program!
#ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
#define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
#include <limits>
#include "gtest/internal/gtest-port.h"
// Ensures that there is at least one operator<< in the global namespace.
// See Message& operator<<(...) below for why.
void operator<<(const testing::internal::Secret&, int);
namespace testing {
// The Message class works like an ostream repeater.
//
// Typical usage:
//
// 1. You stream a bunch of values to a Message object.
// It will remember the text in a stringstream.
// 2. Then you stream the Message object to an ostream.
// This causes the text in the Message to be streamed
// to the ostream.
//
// For example;
//
// testing::Message foo;
// foo << 1 << " != " << 2;
// std::cout << foo;
//
// will print "1 != 2".
//
// Message is not intended to be inherited from. In particular, its
// destructor is not virtual.
//
// Note that stringstream behaves differently in gcc and in MSVC. You
// can stream a NULL char pointer to it in the former, but not in the
// latter (it causes an access violation if you do). The Message
// class hides this difference by treating a NULL char pointer as
// "(null)".
class GTEST_API_ Message {
private:
// The type of basic IO manipulators (endl, ends, and flush) for
// narrow streams.
typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
public:
// Constructs an empty Message.
Message();
// Copy constructor.
Message(const Message& msg) : ss_(new ::std::stringstream) { // NOLINT
*ss_ << msg.GetString();
}
// Constructs a Message from a C-string.
explicit Message(const char* str) : ss_(new ::std::stringstream) {
*ss_ << str;
}
#if GTEST_OS_SYMBIAN
// Streams a value (either a pointer or not) to this object.
template <typename T>
inline Message& operator <<(const T& value) {
StreamHelper(typename internal::is_pointer<T>::type(), value);
return *this;
}
#else
// Streams a non-pointer value to this object.
template <typename T>
inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the global
// namespace, but not other namespaces, including the testing
// namespace which Google Test's Message class is in.
//
// To allow STL containers (and other types that has a << operator
// defined in the global namespace) to be used in Google Test
// assertions, testing::Message must access the custom << operator
// from the global namespace. With this using declaration,
// overloads of << defined in the global namespace and those
// visible via Koenig lookup are both exposed in this function.
using ::operator <<;
*ss_ << val;
return *this;
}
// Streams a pointer value to this object.
//
// This function is an overload of the previous one. When you
// stream a pointer to a Message, this definition will be used as it
// is more specialized. (The C++ Standard, section
// [temp.func.order].) If you stream a non-pointer, then the
// previous definition will be used.
//
// The reason for this overload is that streaming a NULL pointer to
// ostream is undefined behavior. Depending on the compiler, you
// may get "0", "(nil)", "(null)", or an access violation. To
// ensure consistent result across compilers, we always treat NULL
// as "(null)".
template <typename T>
inline Message& operator <<(T* const& pointer) { // NOLINT
if (pointer == NULL) {
*ss_ << "(null)";
} else {
*ss_ << pointer;
}
return *this;
}
#endif // GTEST_OS_SYMBIAN
// Since the basic IO manipulators are overloaded for both narrow
// and wide streams, we have to provide this specialized definition
// of operator <<, even though its body is the same as the
// templatized version above. Without this definition, streaming
// endl or other basic IO manipulators to Message will confuse the
// compiler.
Message& operator <<(BasicNarrowIoManip val) {
*ss_ << val;
return *this;
}
// Instead of 1/0, we want to see true/false for bool values.
Message& operator <<(bool b) {
return *this << (b ? "true" : "false");
}
// These two overloads allow streaming a wide C string to a Message
// using the UTF-8 encoding.
Message& operator <<(const wchar_t* wide_c_str);
Message& operator <<(wchar_t* wide_c_str);
#if GTEST_HAS_STD_WSTRING
// Converts the given wide string to a narrow string using the UTF-8
// encoding, and streams the result to this Message object.
Message& operator <<(const ::std::wstring& wstr);
#endif // GTEST_HAS_STD_WSTRING
#if GTEST_HAS_GLOBAL_WSTRING
// Converts the given wide string to a narrow string using the UTF-8
// encoding, and streams the result to this Message object.
Message& operator <<(const ::wstring& wstr);
#endif // GTEST_HAS_GLOBAL_WSTRING
// Gets the text streamed to this object so far as an std::string.
// Each '\0' character in the buffer is replaced with "\\0".
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
std::string GetString() const;
private:
#if GTEST_OS_SYMBIAN
// These are needed as the Nokia Symbian Compiler cannot decide between
// const T& and const T* in a function template. The Nokia compiler _can_
// decide between class template specializations for T and T*, so a
// tr1::type_traits-like is_pointer works, and we can overload on that.
template <typename T>
inline void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) {
if (pointer == NULL) {
*ss_ << "(null)";
} else {
*ss_ << pointer;
}
}
template <typename T>
inline void StreamHelper(internal::false_type /*is_pointer*/,
const T& value) {
// See the comments in Message& operator <<(const T&) above for why
// we need this using statement.
using ::operator <<;
*ss_ << value;
}
#endif // GTEST_OS_SYMBIAN
// We'll hold the text streamed to this object here.
const internal::scoped_ptr< ::std::stringstream> ss_;
// We declare (but don't implement) this to prevent the compiler
// from implementing the assignment operator.
void operator=(const Message&);
};
// Streams a Message to an ostream.
inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
return os << sb.GetString();
}
namespace internal {
// Converts a streamable value to an std::string. A NULL pointer is
// converted to "(null)". When the input value is a ::string,
// ::std::string, ::wstring, or ::std::wstring object, each NUL
// character in it is replaced with "\\0".
template <typename T>
std::string StreamableToString(const T& streamable) {
return (Message() << streamable).GetString();
}
} // namespace internal
} // namespace testing
#endif // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
================================================
FILE: libs/googleTest/1.7.0/include/gtest/gtest-param-test.h
================================================
// This file was GENERATED by command:
// pump.py gtest-param-test.h.pump
// DO NOT EDIT BY HAND!!!
// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Authors: vladl@google.com (Vlad Losev)
//
// Macros and functions for implementing parameterized tests
// in Google C++ Testing Framework (Google Test)
//
// This file is generated by a SCRIPT. DO NOT EDIT BY HAND!
//
#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
#define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
// Value-parameterized tests allow you to test your code with different
// parameters without writing multiple copies of the same test.
//
// Here is how you use value-parameterized tests:
#if 0
// To write value-parameterized tests, first you should define a fixture
// class. It is usually derived from testing::TestWithParam<T> (see below for
// another inheritance scheme that's sometimes useful in more complicated
// class hierarchies), where the type of your parameter values.
// TestWithParam<T> is itself derived from testing::Test. T can be any
// copyable type. If it's a raw pointer, you are responsible for managing the
// lifespan of the pointed values.
class FooTest : public ::testing::TestWithParam<const char*> {
// You can implement all the usual class fixture members here.
};
// Then, use the TEST_P macro to define as many parameterized tests
// for this fixture as you want. The _P suffix is for "parameterized"
// or "pattern", whichever you prefer to think.
TEST_P(FooTest, DoesBlah) {
// Inside a test, access the test parameter with the GetParam() method
// of the TestWithParam<T> class:
EXPECT_TRUE(foo.Blah(GetParam()));
...
}
TEST_P(FooTest, HasBlahBlah) {
...
}
// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test
// case with any set of parameters you want. Google Test defines a number
// of functions for generating test parameters. They return what we call
// (surprise!) parameter generators. Here is a summary of them, which
// are all in the testing namespace:
//
//
// Range(begin, end [, step]) - Yields values {begin, begin+step,
// begin+step+step, ...}. The values do not
// include end. step defaults to 1.
// Values(v1, v2, ..., vN) - Yields values {v1, v2, ..., vN}.
// ValuesIn(container) - Yields values from a C-style array, an STL
// ValuesIn(begin,end) container, or an iterator range [begin, end).
// Bool() - Yields sequence {false, true}.
// Combine(g1, g2, ..., gN) - Yields all combinations (the Cartesian product
// for the math savvy) of the values generated
// by the N generators.
//
// For more details, see comments at the definitions of these functions below
// in this file.
//
// The following statement will instantiate tests from the FooTest test case
// each with parameter values "meeny", "miny", and "moe".
INSTANTIATE_TEST_CASE_P(InstantiationName,
FooTest,
Values("meeny", "miny", "moe"));
// To distinguish different instances of the pattern, (yes, you
// can instantiate it more then once) the first argument to the
// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the
// actual test case name. Remember to pick unique prefixes for different
// instantiations. The tests from the instantiation above will have
// these names:
//
// * InstantiationName/FooTest.DoesBlah/0 for "meeny"
// * InstantiationName/FooTest.DoesBlah/1 for "miny"
// * InstantiationName/FooTest.DoesBlah/2 for "moe"
// * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
// * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
// * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
//
// You can use these names in --gtest_filter.
//
// This statement will instantiate all tests from FooTest again, each
// with parameter values "cat" and "dog":
const char* pets[] = {"cat", "dog"};
INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
// The tests from the instantiation above will have these names:
//
// * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"
// * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"
// * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
// * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
//
// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests
// in the given test case, whether their definitions come before or
// AFTER the INSTANTIATE_TEST_CASE_P statement.
//
// Please also note that generator expressions (including parameters to the
// generators) are evaluated in InitGoogleTest(), after main() has started.
// This allows the user on one hand, to adjust generator parameters in order
// to dynamically determine a set of tests to run and on the other hand,
// give the user a chance to inspect the generated tests with Google Test
// reflection API before RUN_ALL_TESTS() is executed.
//
// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc
// for more examples.
//
// In the future, we plan to publish the API for defining new parameter
// generators. But for now this interface remains part of the internal
// implementation and is subject to change.
//
//
// A parameterized test fixture must be derived from testing::Test and from
// testing::WithParamInterface<T>, where T is the type of the parameter
// values. Inheriting from TestWithParam<T> satisfies that requirement because
// TestWithParam<T> inherits from both Test and WithParamInterface. In more
// complicated hierarchies, however, it is occasionally useful to inherit
// separately from Test and WithParamInterface. For example:
class BaseTest : public ::testing::Test {
// You can inherit all the usual members for a non-parameterized test
// fixture here.
};
class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
// The usual test fixture members go here too.
};
TEST_F(BaseTest, HasFoo) {
// This is an ordinary non-parameterized test.
}
TEST_P(DerivedTest, DoesBlah) {
// GetParam works just the same here as if you inherit from TestWithParam.
EXPECT_TRUE(foo.Blah(GetParam()));
}
#endif // 0
#include "gtest/internal/gtest-port.h"
#if !GTEST_OS_SYMBIAN
# include <utility>
#endif
// scripts/fuse_gtest.py depends on gtest's own header being #included
// *unconditionally*. Therefore these #includes cannot be moved
// inside #if GTEST_HAS_PARAM_TEST.
#include "gtest/internal/gtest-internal.h"
#include "gtest/internal/gtest-param-util.h"
#include "gtest/internal/gtest-param-util-generated.h"
#if GTEST_HAS_PARAM_TEST
namespace testing {
// Functions producing parameter generators.
//
// Google Test uses these generators to produce parameters for value-
// parameterized tests. When a parameterized test case is instantiated
// with a particular generator, Google Test creates and runs tests
// for each element in the sequence produced by the generator.
//
// In the following sample, tests from test case FooTest are instantiated
// each three times with parameter values 3, 5, and 8:
//
// class FooTest : public TestWithParam<int> { ... };
//
// TEST_P(FooTest, TestThis) {
// }
// TEST_P(FooTest, TestThat) {
// }
// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8));
//
// Range() returns generators providing sequences of values in a range.
//
// Synopsis:
// Range(start, end)
// - returns a generator producing a sequence of values {start, start+1,
// start+2, ..., }.
// Range(start, end, step)
// - returns a generator producing a sequence of values {start, start+step,
// start+step+step, ..., }.
// Notes:
// * The generated sequences never include end. For example, Range(1, 5)
// returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)
// returns a generator producing {1, 3, 5, 7}.
// * start and end must have the same type. That type may be any integral or
// floating-point type or a user defined type satisfying these conditions:
// * It must be assignable (have operator=() defined).
// * It must have operator+() (operator+(int-compatible type) for
// two-operand version).
// * It must have operator<() defined.
// Elements in the resulting sequences will also have that type.
// * Condition start < end must be satisfied in order for resulting sequences
// to contain any elements.
//
template <typename T, typename IncrementT>
internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {
return internal::ParamGenerator<T>(
new internal::RangeGenerator<T, IncrementT>(start, end, step));
}
template <typename T>
internal::ParamGenerator<T> Range(T start, T end) {
return Range(start, end, 1);
}
// ValuesIn() function allows generation of tests with parameters coming from
// a container.
//
// Synopsis:
// ValuesIn(const T (&array)[N])
// - returns a generator producing sequences with elements from
// a C-style array.
// ValuesIn(const Container& container)
// - returns a generator producing sequences with elements from
// an STL-style container.
// ValuesIn(Iterator begin, Iterator end)
// - returns a generator producing sequences with elements from
// a range [begin, end) defined by a pair of STL-style iterators. These
// iterators can also be plain C pointers.
//
// Please note that ValuesIn copies the values from the containers
// passed in and keeps them to generate tests in RUN_ALL_TESTS().
//
// Examples:
//
// This instantiates tests from test case StringTest
// each with C-string values of "foo", "bar", and "baz":
//
// const char* strings[] = {"foo", "bar", "baz"};
// INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings));
//
// This instantiates tests from test case StlStringTest
// each with STL strings with values "a" and "b":
//
// ::std::vector< ::std::string> GetParameterStrings() {
// ::std::vector< ::std::string> v;
// v.push_back("a");
// v.push_back("b");
// return v;
// }
//
// INSTANTIATE_TEST_CASE_P(CharSequence,
// StlStringTest,
// ValuesIn(GetParameterStrings()));
//
//
// This will also instantiate tests from CharTest
// each with parameter values 'a' and 'b':
//
// ::std::list<char> GetParameterChars() {
// ::std::list<char> list;
// list.push_back('a');
// list.push_back('b');
// return list;
// }
// ::std::list<char> l = GetParameterChars();
// INSTANTIATE_TEST_CASE_P(CharSequence2,
// CharTest,
// ValuesIn(l.begin(), l.end()));
//
template <typename ForwardIterator>
internal::ParamGenerator<
typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
ValuesIn(ForwardIterator begin, ForwardIterator end) {
typedef typename ::testing::internal::IteratorTraits<ForwardIterator>
::value_type ParamType;
return internal::ParamGenerator<ParamType>(
new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
}
template <typename T, size_t N>
internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
return ValuesIn(array, array + N);
}
template <class Container>
internal::ParamGenerator<typename Container::value_type> ValuesIn(
const Container& container) {
return ValuesIn(container.begin(), container.end());
}
// Values() allows generating tests from explicitly specified list of
// parameters.
//
// Synopsis:
// Values(T v1, T v2, ..., T vN)
// - returns a generator producing sequences with elements v1, v2, ..., vN.
//
// For example, this instantiates tests from test case BarTest each
// with values "one", "two", and "three":
//
// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three"));
//
// This instantiates tests from test case BazTest each with values 1, 2, 3.5.
// The exact type of values will depend on the type of parameter in BazTest.
//
// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
//
// Currently, Values() supports from 1 to 50 parameters.
//
template <typename T1>
internal::ValueArray1<T1> Values(T1 v1) {
return internal::ValueArray1<T1>(v1);
}
template <typename T1, typename T2>
internal::ValueArray2<T1, T2> Values(T1 v1, T2 v2) {
return internal::ValueArray2<T1, T2>(v1, v2);
}
template <typename T1, typename T2, typename T3>
internal::ValueArray3<T1, T2, T3> Values(T1 v1, T2 v2, T3 v3) {
return internal::ValueArray3<T1, T2, T3>(v1, v2, v3);
}
template <typename T1, typename T2, typename T3, typename T4>
internal::ValueArray4<T1, T2, T3, T4> Values(T1 v1, T2 v2, T3 v3, T4 v4) {
return internal::ValueArray4<T1, T2, T3, T4>(v1, v2, v3, v4);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5>
internal::ValueArray5<T1, T2, T3, T4, T5> Values(T1 v1, T2 v2, T3 v3, T4 v4,
T5 v5) {
return internal::ValueArray5<T1, T2, T3, T4, T5>(v1, v2, v3, v4, v5);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6>
internal::ValueArray6<T1, T2, T3, T4, T5, T6> Values(T1 v1, T2 v2, T3 v3,
T4 v4, T5 v5, T6 v6) {
return internal::ValueArray6<T1, T2, T3, T4, T5, T6>(v1, v2, v3, v4, v5, v6);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7>
internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7> Values(T1 v1, T2 v2, T3 v3,
T4 v4, T5 v5, T6 v6, T7 v7) {
return internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7>(v1, v2, v3, v4, v5,
v6, v7);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8>
internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8> Values(T1 v1, T2 v2,
T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) {
return internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8>(v1, v2, v3, v4,
v5, v6, v7, v8);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9>
internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9> Values(T1 v1, T2 v2,
T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) {
return internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(v1, v2, v3,
v4, v5, v6, v7, v8, v9);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10>
internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Values(T1 v1,
T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) {
return internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(v1,
v2, v3, v4, v5, v6, v7, v8, v9, v10);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11>
internal::ValueArray11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
T11> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
T10 v10, T11 v11) {
return internal::ValueArray11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
T11>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12>
internal::ValueArray12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
T10 v10, T11 v11, T12 v12) {
return internal::ValueArray12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13>
internal::ValueArray13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
T13> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
T10 v10, T11 v11, T12 v12, T13 v13) {
return internal::ValueArray13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14>
internal::ValueArray14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) {
return internal::ValueArray14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
v14);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15>
internal::ValueArray15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) {
return internal::ValueArray15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
v13, v14, v15);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16>
internal::ValueArray16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
T16 v16) {
return internal::ValueArray16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
v12, v13, v14, v15, v16);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17>
internal::ValueArray17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
T16 v16, T17 v17) {
return internal::ValueArray17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
v11, v12, v13, v14, v15, v16, v17);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18>
internal::ValueArray18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
T16 v16, T17 v17, T18 v18) {
return internal::ValueArray18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
v10, v11, v12, v13, v14, v15, v16, v17, v18);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19>
internal::ValueArray19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
T15 v15, T16 v16, T17 v17, T18 v18, T19 v19) {
return internal::ValueArray19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19>(v1, v2, v3, v4, v5, v6, v7, v8,
v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20>
internal::ValueArray20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20> Values(T1 v1, T2 v2, T3 v3, T4 v4,
T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20) {
return internal::ValueArray20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20>(v1, v2, v3, v4, v5, v6, v7,
v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21>
internal::ValueArray21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21> Values(T1 v1, T2 v2, T3 v3, T4 v4,
T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21) {
return internal::ValueArray21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(v1, v2, v3, v4, v5, v6,
v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22>
internal::ValueArray22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22> Values(T1 v1, T2 v2, T3 v3,
T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
T21 v21, T22 v22) {
return internal::ValueArray22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>(v1, v2, v3, v4,
v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
v20, v21, v22);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23>
internal::ValueArray23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Values(T1 v1, T2 v2,
T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
T21 v21, T22 v22, T23 v23) {
return internal::ValueArray23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>(v1, v2, v3,
v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
v20, v21, v22, v23);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24>
internal::ValueArray24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Values(T1 v1, T2 v2,
T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
T21 v21, T22 v22, T23 v23, T24 v24) {
return internal::ValueArray24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>(v1, v2,
v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
v19, v20, v21, v22, v23, v24);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25>
internal::ValueArray25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Values(T1 v1,
T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11,
T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19,
T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25) {
return internal::ValueArray25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>(v1,
v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17,
v18, v19, v20, v21, v22, v23, v24, v25);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26>
internal::ValueArray26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
T26 v26) {
return internal::ValueArray26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27>
internal::ValueArray27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
T27> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
T26 v26, T27 v27) {
return internal::ValueArray27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14,
v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28>
internal::ValueArray28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
T28> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
T26 v26, T27 v27, T28 v28) {
return internal::ValueArray28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27,
v28);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29>
internal::ValueArray29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
T26 v26, T27 v27, T28 v28, T29 v29) {
return internal::ValueArray29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26,
v27, v28, v29);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30>
internal::ValueArray30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) {
return internal::ValueArray30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25,
v26, v27, v28, v29, v30);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31>
internal::ValueArray31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) {
return internal::ValueArray31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24,
v25, v26, v27, v28, v29, v30, v31);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32>
internal::ValueArray32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
T32 v32) {
return internal::ValueArray32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
v24, v25, v26, v27, v28, v29, v30, v31, v32);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33>
internal::ValueArray33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
T32 v32, T33 v33) {
return internal::ValueArray33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33>(v1, v2, v3, v4, v5, v6, v7, v8,
v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
v24, v25, v26, v27, v28, v29, v30, v31, v32, v33);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33, typename T34>
internal::ValueArray34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33, T34> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22,
T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30,
T31 v31, T32 v32, T33 v33, T34 v34) {
return internal::ValueArray34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33, T34>(v1, v2, v3, v4, v5, v6, v7,
v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22,
v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33, typename T34, typename T35>
internal::ValueArray35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33, T34, T35> Values(T1 v1, T2 v2, T3 v3, T4 v4,
T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35) {
return internal::ValueArray35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33, T34, T35>(v1, v2, v3, v4, v5, v6,
v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33, typename T34, typename T35,
typename T36>
internal::ValueArray36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33, T34, T35, T36> Values(T1 v1, T2 v2, T3 v3, T4 v4,
T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36) {
return internal::ValueArray36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36>(v1, v2, v3, v4,
v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
v34, v35, v36);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33, typename T34, typename T35,
typename T36, typename T37>
internal::ValueArray37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33, T34, T35, T36, T37> Values(T1 v1, T2 v2, T3 v3,
T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
T37 v37) {
return internal::ValueArray37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37>(v1, v2, v3,
v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
v34, v35, v36, v37);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33, typename T34, typename T35,
typename T36, typename T37, typename T38>
internal::ValueArray38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> Values(T1 v1, T2 v2,
T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
T37 v37, T38 v38) {
return internal::ValueArray38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38>(v1, v2,
v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32,
v33, v34, v35, v36, v37, v38);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33, typename T34, typename T35,
typename T36, typename T37, typename T38, typename T39>
internal::ValueArray39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Values(T1 v1, T2 v2,
T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
T37 v37, T38 v38, T39 v39) {
return internal::ValueArray39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39>(v1,
v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17,
v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
v32, v33, v34, v35, v36, v37, v38, v39);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33, typename T34, typename T35,
typename T36, typename T37, typename T38, typename T39, typename T40>
internal::ValueArray40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Values(T1 v1,
T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11,
T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19,
T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27,
T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35,
T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) {
return internal::ValueArray40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
T40>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29,
v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33, typename T34, typename T35,
typename T36, typename T37, typename T38, typename T39, typename T40,
typename T41>
internal::ValueArray41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
T41> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41) {
return internal::ValueArray41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
T40, T41>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14,
v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28,
v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33, typename T34, typename T35,
typename T36, typename T37, typename T38, typename T39, typename T40,
typename T41, typename T42>
internal::ValueArray42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
T42> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
T42 v42) {
return internal::ValueArray42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
T40, T41, T42>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27,
v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41,
v42);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33, typename T34, typename T35,
typename T36, typename T37, typename T38, typename T39, typename T40,
typename T41, typename T42, typename T43>
internal::ValueArray43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
T43> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
T42 v42, T43 v43) {
return internal::ValueArray43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
T40, T41, T42, T43>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26,
v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40,
v41, v42, v43);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33, typename T34, typename T35,
typename T36, typename T37, typename T38, typename T39, typename T40,
typename T41, typename T42, typename T43, typename T44>
internal::ValueArray44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
T44> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
T42 v42, T43 v43, T44 v44) {
return internal::ValueArray44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
T40, T41, T42, T43, T44>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25,
v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39,
v40, v41, v42, v43, v44);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33, typename T34, typename T35,
typename T36, typename T37, typename T38, typename T39, typename T40,
typename T41, typename T42, typename T43, typename T44, typename T45>
internal::ValueArray45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
T44, T45> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32,
T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40,
T41 v41, T42 v42, T43 v43, T44 v44, T45 v45) {
return internal::ValueArray45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
T40, T41, T42, T43, T44, T45>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24,
v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38,
v39, v40, v41, v42, v43, v44, v45);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33, typename T34, typename T35,
typename T36, typename T37, typename T38, typename T39, typename T40,
typename T41, typename T42, typename T43, typename T44, typename T45,
typename T46>
internal::ValueArray46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
T44, T45, T46> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) {
return internal::ValueArray46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
T40, T41, T42, T43, T44, T45, T46>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37,
v38, v39, v40, v41, v42, v43, v44, v45, v46);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33, typename T34, typename T35,
typename T36, typename T37, typename T38, typename T39, typename T40,
typename T41, typename T42, typename T43, typename T44, typename T45,
typename T46, typename T47>
internal::ValueArray47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
T44, T45, T46, T47> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) {
return internal::ValueArray47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
T40, T41, T42, T43, T44, T45, T46, T47>(v1, v2, v3, v4, v5, v6, v7, v8,
v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37,
v38, v39, v40, v41, v42, v43, v44, v45, v46, v47);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33, typename T34, typename T35,
typename T36, typename T37, typename T38, typename T39, typename T40,
typename T41, typename T42, typename T43, typename T44, typename T45,
typename T46, typename T47, typename T48>
internal::ValueArray48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
T44, T45, T46, T47, T48> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47,
T48 v48) {
return internal::ValueArray48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
T40, T41, T42, T43, T44, T45, T46, T47, T48>(v1, v2, v3, v4, v5, v6, v7,
v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22,
v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36,
v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33, typename T34, typename T35,
typename T36, typename T37, typename T38, typename T39, typename T40,
typename T41, typename T42, typename T43, typename T44, typename T45,
typename T46, typename T47, typename T48, typename T49>
internal::ValueArray49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
T44, T45, T46, T47, T48, T49> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22,
T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30,
T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38,
T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46,
T47 v47, T48 v48, T49 v49) {
return internal::ValueArray49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
T40, T41, T42, T43, T44, T45, T46, T47, T48, T49>(v1, v2, v3, v4, v5, v6,
v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35,
v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14, typename T15,
typename T16, typename T17, typename T18, typename T19, typename T20,
typename T21, typename T22, typename T23, typename T24, typename T25,
typename T26, typename T27, typename T28, typename T29, typename T30,
typename T31, typename T32, typename T33, typename T34, typename T35,
typename T36, typename T37, typename T38, typename T39, typename T40,
typename T41, typename T42, typename T43, typename T44, typename T45,
typename T46, typename T47, typename T48, typename T49, typename T50>
internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
T44, T45, T46, T47, T48, T49, T50> Values(T1 v1, T2 v2, T3 v3, T4 v4,
T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37,
T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45,
T46 v46, T47 v47, T48 v48, T49 v49, T50 v50) {
return internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50>(v1, v2, v3, v4,
v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47,
v48, v49, v50);
}
// Bool() allows generating tests with parameters in a set of (false, true).
//
// Synopsis:
// Bool()
// - returns a generator producing sequences with elements {false, true}.
//
// It is useful when testing code that depends on Boolean flags. Combinations
// of multiple flags can be tested when several Bool()'s are combined using
// Combine() function.
//
// In the following example all tests in the test case FlagDependentTest
// will be instantiated twice with parameters false and true.
//
// class FlagDependentTest : public testing::TestWithParam<bool> {
// virtual void SetUp() {
// external_flag = GetParam();
// }
// }
// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool());
//
inline internal::ParamGenerator<bool> Bool() {
return Values(false, true);
}
# if GTEST_HAS_COMBINE
// Combine() allows the user to combine two or more sequences to produce
// values of a Cartesian product of those sequences' elements.
//
// Synopsis:
// Combine(gen1, gen2, ..., genN)
// - returns a generator producing sequences with elements coming from
// the Cartesian product of elements from the sequences generated by
// gen1, gen2, ..., genN. The sequence elements will have a type of
// tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
// of elements from sequences produces by gen1, gen2, ..., genN.
//
// Combine can have up to 10 arguments. This number is currently limited
// by the maximum number of elements in the tuple implementation used by Google
// Test.
//
// Example:
//
// This will instantiate tests in test case AnimalTest each one with
// the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
// tuple("dog", BLACK), and tuple("dog", WHITE):
//
// enum Color { BLACK, GRAY, WHITE };
// class AnimalTest
// : public testing::TestWithParam<tuple<const char*, Color> > {...};
//
// TEST_P(AnimalTest, AnimalLooksNice) {...}
//
// INSTANTIATE_TEST_CASE_P(AnimalVariations, AnimalTest,
// Combine(Values("cat", "dog"),
// Values(BLACK, WHITE)));
//
// This will instantiate tests in FlagDependentTest with all variations of two
// Boolean flags:
//
// class FlagDependentTest
// : public testing::TestWithParam<tuple<bool, bool> > {
// virtual void SetUp() {
// // Assigns external_flag_1 and external_flag_2 values from the tuple.
// tie(external_flag_1, external_flag_2) = GetParam();
// }
// };
//
// TEST_P(FlagDependentTest, TestFeature1) {
// // Test your code using external_flag_1 and external_flag_2 here.
// }
// INSTANTIATE_TEST_CASE_P(TwoBoolSequence, FlagDependentTest,
// Combine(Bool(), Bool()));
//
template <typename Generator1, typename Generator2>
internal::CartesianProductHolder2<Generator1, Generator2> Combine(
const Generator1& g1, const Generator2& g2) {
return internal::CartesianProductHolder2<Generator1, Generator2>(
g1, g2);
}
template <typename Generator1, typename Generator2, typename Generator3>
internal::CartesianProductHolder3<Generator1, Generator2, Generator3> Combine(
const Generator1& g1, const Generator2& g2, const Generator3& g3) {
return internal::CartesianProductHolder3<Generator1, Generator2, Generator3>(
g1, g2, g3);
}
template <typename Generator1, typename Generator2, typename Generator3,
typename Generator4>
internal::CartesianProductHolder4<Generator1, Generator2, Generator3,
Generator4> Combine(
const Generator1& g1, const Generator2& g2, const Generator3& g3,
const Generator4& g4) {
return internal::CartesianProductHolder4<Generator1, Generator2, Generator3,
Generator4>(
g1, g2, g3, g4);
}
template <typename Generator1, typename Generator2, typename Generator3,
typename Generator4, typename Generator5>
internal::CartesianProductHolder5<Generator1, Generator2, Generator3,
Generator4, Generator5> Combine(
const Generator1& g1, const Generator2& g2, const Generator3& g3,
const Generator4& g4, const Generator5& g5) {
return internal::CartesianProductHolder5<Generator1, Generator2, Generator3,
Generator4, Generator5>(
g1, g2, g3, g4, g5);
}
template <typename Generator1, typename Generator2, typename Generator3,
typename Generator4, typename Generator5, typename Generator6>
internal::CartesianProductHolder6<Generator1, Generator2, Generator3,
Generator4, Generator5, Generator6> Combine(
const Generator1& g1, const Generator2& g2, const Generator3& g3,
const Generator4& g4, const Generator5& g5, const Generator6& g6) {
return internal::CartesianProductHolder6<Generator1, Generator2, Generator3,
Generator4, Generator5, Generator6>(
g1, g2, g3, g4, g5, g6);
}
template <typename Generator1, typename Generator2, typename Generator3,
typename Generator4, typename Generator5, typename Generator6,
typename Generator7>
internal::CartesianProductHolder7<Generator1, Generator2, Generator3,
Generator4, Generator5, Generator6, Generator7> Combine(
const Generator1& g1, const Generator2& g2, const Generator3& g3,
const Generator4& g4, const Generator5& g5, const Generator6& g6,
const Generator7& g7) {
return internal::CartesianProductHolder7<Generator1, Generator2, Generator3,
Generator4, Generator5, Generator6, Generator7>(
g1, g2, g3, g4, g5, g6, g7);
}
template <typename Generator1, typename Generator2, typename Generator3,
typename Generator4, typename Generator5, typename Generator6,
typename Generator7, typename Generator8>
internal::CartesianProductHolder8<Generator1, Generator2, Generator3,
Generator4, Generator5, Generator6, Generator7, Generator8> Combine(
const Generator1& g1, const Generator2& g2, const Generator3& g3,
const Generator4& g4, const Generator5& g5, const Generator6& g6,
const Generator7& g7, const Generator8& g8) {
return internal::CartesianProductHolder8<Generator1, Generator2, Generator3,
Generator4, Generator5, Generator6, Generator7, Generator8>(
g1, g2, g3, g4, g5, g6, g7, g8);
}
template <typename Generator1, typename Generator2, typename Generator3,
typename Generator4, typename Generator5, typename Generator6,
typename Generator7, typename Generator8, typename Generator9>
internal::CartesianProductHolder9<Generator1, Generator2, Generator3,
Generator4, Generator5, Generator6, Generator7, Generator8,
Generator9> Combine(
const Generator1& g1, const Generator2& g2, const Generator3& g3,
const Generator4& g4, const Generator5& g5, const Generator6& g6,
const Generator7& g7, const Generator8& g8, const Generator9& g9) {
return internal::CartesianProductHolder9<Generator1, Generator2, Generator3,
Generator4, Generator5, Generator6, Generator7, Generator8, Generator9>(
g1, g2, g3, g4, g5, g6, g7, g8, g9);
}
template <typename Generator1, typename Generator2, typename Generator3,
typename Generator4, typename Generator5, typename Generator6,
typename Generator7, typename Generator8, typename Generator9,
typename Generator10>
internal::CartesianProductHolder10<Generator1, Generator2, Generator3,
Generator4, Generator5, Generator6, Generator7, Generator8, Generator9,
Generator10> Combine(
const Generator1& g1, const Generator2& g2, const Generator3& g3,
const Generator4& g4, const Generator5& g5, const Generator6& g6,
const Generator7& g7, const Generator8& g8, const Generator9& g9,
const Generator10& g10) {
return internal::CartesianProductHolder10<Generator1, Generator2, Generator3,
Generator4, Generator5, Generator6, Generator7, Generator8, Generator9,
Generator10>(
g1, g2, g3, g4, g5, g6, g7, g8, g9, g10);
}
# endif // GTEST_HAS_COMBINE
# define TEST_P(test_case_name, test_name) \
class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
: public test_case_name { \
public: \
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \
virtual void TestBody(); \
private: \
static int AddToRegistry() { \
::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
GetTestCasePatternHolder<test_case_name>(\
#test_case_name, __FILE__, __LINE__)->AddTestPattern(\
#test_case_name, \
#test_name, \
new ::testing::internal::TestMetaFactory< \
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>()); \
return 0; \
} \
static int gtest_registering_dummy_; \
GTEST_DISALLOW_COPY_AND_ASSIGN_(\
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
}; \
int GTEST_TEST_CLASS_NAME_(test_case_name, \
test_name)::gtest_registering_dummy_ = \
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \
void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
# define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator) \
::testing::internal::ParamGenerator<test_case_name::ParamType> \
gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \
int gtest_##prefix##test_case_name##_dummy_ = \
::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
GetTestCasePatternHolder<test_case_name>(\
#test_case_name, __FILE__, __LINE__)->AddTestCaseInstantiation(\
#prefix, \
>est_##prefix##test_case_name##_EvalGenerator_, \
__FILE__, __LINE__)
} // namespace testing
#endif // GTEST_HAS_PARAM_TEST
#endif // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
================================================
FILE: libs/googleTest/1.7.0/include/gtest/gtest-param-test.h.pump
================================================
$$ -*- mode: c++; -*-
$var n = 50 $$ Maximum length of Values arguments we want to support.
$var maxtuple = 10 $$ Maximum number of Combine arguments we want to support.
// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Authors: vladl@google.com (Vlad Losev)
//
// Macros and functions for implementing parameterized tests
// in Google C++ Testing Framework (Google Test)
//
// This file is generated by a SCRIPT. DO NOT EDIT BY HAND!
//
#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
#define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
// Value-parameterized tests allow you to test your code with different
// parameters without writing multiple copies of the same test.
//
// Here is how you use value-parameterized tests:
#if 0
// To write value-parameterized tests, first you should define a fixture
// class. It is usually derived from testing::TestWithParam<T> (see below for
// another inheritance scheme that's sometimes useful in more complicated
// class hierarchies), where the type of your parameter values.
// TestWithParam<T> is itself derived from testing::Test. T can be any
// copyable type. If it's a raw pointer, you are responsible for managing the
// lifespan of the pointed values.
class FooTest : public ::testing::TestWithParam<const char*> {
// You can implement all the usual class fixture members here.
};
// Then, use the TEST_P macro to define as many parameterized tests
// for this fixture as you want. The _P suffix is for "parameterized"
// or "pattern", whichever you prefer to think.
TEST_P(FooTest, DoesBlah) {
// Inside a test, access the test parameter with the GetParam() method
// of the TestWithParam<T> class:
EXPECT_TRUE(foo.Blah(GetParam()));
...
}
TEST_P(FooTest, HasBlahBlah) {
...
}
// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test
// case with any set of parameters you want. Google Test defines a number
// of functions for generating test parameters. They return what we call
// (surprise!) parameter generators. Here is a summary of them, which
// are all in the testing namespace:
//
//
// Range(begin, end [, step]) - Yields values {begin, begin+step,
// begin+step+step, ...}. The values do not
// include end. step defaults to 1.
// Values(v1, v2, ..., vN) - Yields values {v1, v2, ..., vN}.
// ValuesIn(container) - Yields values from a C-style array, an STL
// ValuesIn(begin,end) container, or an iterator range [begin, end).
// Bool() - Yields sequence {false, true}.
// Combine(g1, g2, ..., gN) - Yields all combinations (the Cartesian product
// for the math savvy) of the values generated
// by the N generators.
//
// For more details, see comments at the definitions of these functions below
// in this file.
//
// The following statement will instantiate tests from the FooTest test case
// each with parameter values "meeny", "miny", and "moe".
INSTANTIATE_TEST_CASE_P(InstantiationName,
FooTest,
Values("meeny", "miny", "moe"));
// To distinguish different instances of the pattern, (yes, you
// can instantiate it more then once) the first argument to the
// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the
// actual test case name. Remember to pick unique prefixes for different
// instantiations. The tests from the instantiation above will have
// these names:
//
// * InstantiationName/FooTest.DoesBlah/0 for "meeny"
// * InstantiationName/FooTest.DoesBlah/1 for "miny"
// * InstantiationName/FooTest.DoesBlah/2 for "moe"
// * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
// * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
// * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
//
// You can use these names in --gtest_filter.
//
// This statement will instantiate all tests from FooTest again, each
// with parameter values "cat" and "dog":
const char* pets[] = {"cat", "dog"};
INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
// The tests from the instantiation above will have these names:
//
// * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"
// * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"
// * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
// * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
//
// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests
// in the given test case, whether their definitions come before or
// AFTER the INSTANTIATE_TEST_CASE_P statement.
//
// Please also note that generator expressions (including parameters to the
// generators) are evaluated in InitGoogleTest(), after main() has started.
// This allows the user on one hand, to adjust generator parameters in order
// to dynamically determine a set of tests to run and on the other hand,
// give the user a chance to inspect the generated tests with Google Test
// reflection API before RUN_ALL_TESTS() is executed.
//
// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc
// for more examples.
//
// In the future, we plan to publish the API for defining new parameter
// generators. But for now this interface remains part of the internal
// implementation and is subject to change.
//
//
// A parameterized test fixture must be derived from testing::Test and from
// testing::WithParamInterface<T>, where T is the type of the parameter
// values. Inheriting from TestWithParam<T> satisfies that requirement because
// TestWithParam<T> inherits from both Test and WithParamInterface. In more
// complicated hierarchies, however, it is occasionally useful to inherit
// separately from Test and WithParamInterface. For example:
class BaseTest : public ::testing::Test {
// You can inherit all the usual members for a non-parameterized test
// fixture here.
};
class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
// The usual test fixture members go here too.
};
TEST_F(BaseTest, HasFoo) {
// This is an ordinary non-parameterized test.
}
TEST_P(DerivedTest, DoesBlah) {
// GetParam works just the same here as if you inherit from TestWithParam.
EXPECT_TRUE(foo.Blah(GetParam()));
}
#endif // 0
#include "gtest/internal/gtest-port.h"
#if !GTEST_OS_SYMBIAN
# include <utility>
#endif
// scripts/fuse_gtest.py depends on gtest's own header being #included
// *unconditionally*. Therefore these #includes cannot be moved
// inside #if GTEST_HAS_PARAM_TEST.
#include "gtest/internal/gtest-internal.h"
#include "gtest/internal/gtest-param-util.h"
#include "gtest/internal/gtest-param-util-generated.h"
#if GTEST_HAS_PARAM_TEST
namespace testing {
// Functions producing parameter generators.
//
// Google Test uses these generators to produce parameters for value-
// parameterized tests. When a parameterized test case is instantiated
// with a particular generator, Google Test creates and runs tests
// for each element in the sequence produced by the generator.
//
// In the following sample, tests from test case FooTest are instantiated
// each three times with parameter values 3, 5, and 8:
//
// class FooTest : public TestWithParam<int> { ... };
//
// TEST_P(FooTest, TestThis) {
// }
// TEST_P(FooTest, TestThat) {
// }
// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8));
//
// Range() returns generators providing sequences of values in a range.
//
// Synopsis:
// Range(start, end)
// - returns a generator producing a sequence of values {start, start+1,
// start+2, ..., }.
// Range(start, end, step)
// - returns a generator producing a sequence of values {start, start+step,
// start+step+step, ..., }.
// Notes:
// * The generated sequences never include end. For example, Range(1, 5)
// returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)
// returns a generator producing {1, 3, 5, 7}.
// * start and end must have the same type. That type may be any integral or
// floating-point type or a user defined type satisfying these conditions:
// * It must be assignable (have operator=() defined).
// * It must have operator+() (operator+(int-compatible type) for
// two-operand version).
// * It must have operator<() defined.
// Elements in the resulting sequences will also have that type.
// * Condition start < end must be satisfied in order for resulting sequences
// to contain any elements.
//
template <typename T, typename IncrementT>
internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {
return internal::ParamGenerator<T>(
new internal::RangeGenerator<T, IncrementT>(start, end, step));
}
template <typename T>
internal::ParamGenerator<T> Range(T start, T end) {
return Range(start, end, 1);
}
// ValuesIn() function allows generation of tests with parameters coming from
// a container.
//
// Synopsis:
// ValuesIn(const T (&array)[N])
// - returns a generator producing sequences with elements from
// a C-style array.
// ValuesIn(const Container& container)
// - returns a generator producing sequences with elements from
// an STL-style container.
// ValuesIn(Iterator begin, Iterator end)
// - returns a generator producing sequences with elements from
// a range [begin, end) defined by a pair of STL-style iterators. These
// iterators can also be plain C pointers.
//
// Please note that ValuesIn copies the values from the containers
// passed in and keeps them to generate tests in RUN_ALL_TESTS().
//
// Examples:
//
// This instantiates tests from test case StringTest
// each with C-string values of "foo", "bar", and "baz":
//
// const char* strings[] = {"foo", "bar", "baz"};
// INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings));
//
// This instantiates tests from test case StlStringTest
// each with STL strings with values "a" and "b":
//
// ::std::vector< ::std::string> GetParameterStrings() {
// ::std::vector< ::std::string> v;
// v.push_back("a");
// v.push_back("b");
// return v;
// }
//
// INSTANTIATE_TEST_CASE_P(CharSequence,
// StlStringTest,
// ValuesIn(GetParameterStrings()));
//
//
// This will also instantiate tests from CharTest
// each with parameter values 'a' and 'b':
//
// ::std::list<char> GetParameterChars() {
// ::std::list<char> list;
// list.push_back('a');
// list.push_back('b');
// return list;
// }
// ::std::list<char> l = GetParameterChars();
// INSTANTIATE_TEST_CASE_P(CharSequence2,
// CharTest,
// ValuesIn(l.begin(), l.end()));
//
template <typename ForwardIterator>
internal::ParamGenerator<
typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
ValuesIn(ForwardIterator begin, ForwardIterator end) {
typedef typename ::testing::internal::IteratorTraits<ForwardIterator>
::value_type ParamType;
return internal::ParamGenerator<ParamType>(
new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
}
template <typename T, size_t N>
internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
return ValuesIn(array, array + N);
}
template <class Container>
internal::ParamGenerator<typename Container::value_type> ValuesIn(
const Container& container) {
return ValuesIn(container.begin(), container.end());
}
// Values() allows generating tests from explicitly specified list of
// parameters.
//
// Synopsis:
// Values(T v1, T v2, ..., T vN)
// - returns a generator producing sequences with elements v1, v2, ..., vN.
//
// For example, this instantiates tests from test case BarTest each
// with values "one", "two", and "three":
//
// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three"));
//
// This instantiates tests from test case BazTest each with values 1, 2, 3.5.
// The exact type of values will depend on the type of parameter in BazTest.
//
// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
//
// Currently, Values() supports from 1 to $n parameters.
//
$range i 1..n
$for i [[
$range j 1..i
template <$for j, [[typename T$j]]>
internal::ValueArray$i<$for j, [[T$j]]> Values($for j, [[T$j v$j]]) {
return internal::ValueArray$i<$for j, [[T$j]]>($for j, [[v$j]]);
}
]]
// Bool() allows generating tests with parameters in a set of (false, true).
//
// Synopsis:
// Bool()
// - returns a generator producing sequences with elements {false, true}.
//
// It is useful when testing code that depends on Boolean flags. Combinations
// of multiple flags can be tested when several Bool()'s are combined using
// Combine() function.
//
// In the following example all tests in the test case FlagDependentTest
// will be instantiated twice with parameters false and true.
//
// class FlagDependentTest : public testing::TestWithParam<bool> {
// virtual void SetUp() {
// external_flag = GetParam();
// }
// }
// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool());
//
inline internal::ParamGenerator<bool> Bool() {
return Values(false, true);
}
# if GTEST_HAS_COMBINE
// Combine() allows the user to combine two or more sequences to produce
// values of a Cartesian product of those sequences' elements.
//
// Synopsis:
// Combine(gen1, gen2, ..., genN)
// - returns a generator producing sequences with elements coming from
// the Cartesian product of elements from the sequences generated by
// gen1, gen2, ..., genN. The sequence elements will have a type of
// tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
// of elements from sequences produces by gen1, gen2, ..., genN.
//
// Combine can have up to $maxtuple arguments. This number is currently limited
// by the maximum number of elements in the tuple implementation used by Google
// Test.
//
// Example:
//
// This will instantiate tests in test case AnimalTest each one with
// the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
// tuple("dog", BLACK), and tuple("dog", WHITE):
//
// enum Color { BLACK, GRAY, WHITE };
// class AnimalTest
// : public testing::TestWithParam<tuple<const char*, Color> > {...};
//
// TEST_P(AnimalTest, AnimalLooksNice) {...}
//
// INSTANTIATE_TEST_CASE_P(AnimalVariations, AnimalTest,
// Combine(Values("cat", "dog"),
// Values(BLACK, WHITE)));
//
// This will instantiate tests in FlagDependentTest with all variations of two
// Boolean flags:
//
// class FlagDependentTest
// : public testing::TestWithParam<tuple<bool, bool> > {
// virtual void SetUp() {
// // Assigns external_flag_1 and external_flag_2 values from the tuple.
// tie(external_flag_1, external_flag_2) = GetParam();
// }
// };
//
// TEST_P(FlagDependentTest, TestFeature1) {
// // Test your code using external_flag_1 and external_flag_2 here.
// }
// INSTANTIATE_TEST_CASE_P(TwoBoolSequence, FlagDependentTest,
// Combine(Bool(), Bool()));
//
$range i 2..maxtuple
$for i [[
$range j 1..i
template <$for j, [[typename Generator$j]]>
internal::CartesianProductHolder$i<$for j, [[Generator$j]]> Combine(
$for j, [[const Generator$j& g$j]]) {
return internal::CartesianProductHolder$i<$for j, [[Generator$j]]>(
$for j, [[g$j]]);
}
]]
# endif // GTEST_HAS_COMBINE
# define TEST_P(test_case_name, test_name) \
class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
: public test_case_name { \
public: \
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \
virtual void TestBody(); \
private: \
static int AddToRegistry() { \
::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
GetTestCasePatternHolder<test_case_name>(\
#test_case_name, __FILE__, __LINE__)->AddTestPattern(\
#test_case_name, \
#test_name, \
new ::testing::internal::TestMetaFactory< \
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>()); \
return 0; \
} \
static int gtest_registering_dummy_; \
GTEST_DISALLOW_COPY_AND_ASSIGN_(\
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
}; \
int GTEST_TEST_CLASS_NAME_(test_case_name, \
test_name)::gtest_registering_dummy_ = \
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \
void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
# define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator) \
::testing::internal::ParamGenerator<test_case_name::ParamType> \
gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \
int gtest_##prefix##test_case_name##_dummy_ = \
::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
GetTestCasePatternHolder<test_case_name>(\
#test_case_name, __FILE__, __LINE__)->AddTestCaseInstantiation(\
#prefix, \
>est_##prefix##test_case_name##_EvalGenerator_, \
__FILE__, __LINE__)
} // namespace testing
#endif // GTEST_HAS_PARAM_TEST
#endif // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
================================================
FILE: libs/googleTest/1.7.0/include/gtest/gtest-printers.h
================================================
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: wan@google.com (Zhanyong Wan)
// Google Test - The Google C++ Testing Framework
//
// This file implements a universal value printer that can print a
// value of any type T:
//
// void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
//
// A user can teach this function how to print a class type T by
// defining either operator<<() or PrintTo() in the namespace that
// defines T. More specifically, the FIRST defined function in the
// following list will be used (assuming T is defined in namespace
// foo):
//
// 1. foo::PrintTo(const T&, ostream*)
// 2. operator<<(ostream&, const T&) defined in either foo or the
// global namespace.
//
// If none of the above is defined, it will print the debug string of
// the value if it is a protocol buffer, or print the raw bytes in the
// value otherwise.
//
// To aid debugging: when T is a reference type, the address of the
// value is also printed; when T is a (const) char pointer, both the
// pointer value and the NUL-terminated string it points to are
// printed.
//
// We also provide some convenient wrappers:
//
// // Prints a value to a string. For a (const or not) char
// // pointer, the NUL-terminated string (but not the pointer) is
// // printed.
// std::string ::testing::PrintToString(const T& value);
//
// // Prints a value tersely: for a reference type, the referenced
// // value (but not the address) is printed; for a (const or not) char
// // pointer, the NUL-terminated string (but not the pointer) is
// // printed.
// void ::testing::internal::UniversalTersePrint(const T& value, ostream*);
//
// // Prints value using the type inferred by the compiler. The difference
// // from UniversalTersePrint() is that this function prints both the
// // pointer and the NUL-terminated string for a (const or not) char pointer.
// void ::testing::internal::UniversalPrint(const T& value, ostream*);
//
// // Prints the fields of a tuple tersely to a string vector, one
// // element for each field. Tuple support must be enabled in
// // gtest-port.h.
// std::vector<string> UniversalTersePrintTupleFieldsToStrings(
// const Tuple& value);
//
// Known limitation:
//
// The print primitives print the elements of an STL-style container
// using the compiler-inferred type of *iter where iter is a
// const_iterator of the container. When const_iterator is an input
// iterator but not a forward iterator, this inferred type may not
// match value_type, and the print output may be incorrect. In
// practice, this is rarely a problem as for most containers
// const_iterator is a forward iterator. We'll fix this if there's an
// actual need for it. Note that this fix cannot rely on value_type
// being defined as many user-defined container types don't have
// value_type.
#ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
#define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
#include <ostream> // NOLINT
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#include "gtest/internal/gtest-port.h"
#include "gtest/internal/gtest-internal.h"
namespace testing {
// Definitions in the 'internal' and 'internal2' name spaces are
// subject to change without notice. DO NOT USE THEM IN USER CODE!
namespace internal2 {
// Prints the given number of bytes in the given object to the given
// ostream.
GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
size_t count,
::std::ostream* os);
// For selecting which printer to use when a given type has neither <<
// nor PrintTo().
enum TypeKind {
kProtobuf, // a protobuf type
kConvertibleToInteger, // a type implicitly convertible to BiggestInt
// (e.g. a named or unnamed enum type)
kOtherType // anything else
};
// TypeWithoutFormatter<T, kTypeKind>::PrintValue(value, os) is called
// by the universal printer to print a value of type T when neither
// operator<< nor PrintTo() is defined for T, where kTypeKind is the
// "kind" of T as defined by enum TypeKind.
template <typename T, TypeKind kTypeKind>
class TypeWithoutFormatter {
public:
// This default version is called when kTypeKind is kOtherType.
static void PrintValue(const T& value, ::std::ostream* os) {
PrintBytesInObjectTo(reinterpret_cast<const unsigned char*>(&value),
sizeof(value), os);
}
};
// We print a protobuf using its ShortDebugString() when the string
// doesn't exceed this many characters; otherwise we print it using
// DebugString() for better readability.
const size_t kProtobufOneLinerMaxLength = 50;
template <typename T>
class TypeWithoutFormatter<T, kProtobuf> {
public:
static void PrintValue(const T& value, ::std::ostream* os) {
const ::testing::internal::string short_str = value.ShortDebugString();
const ::testing::internal::string pretty_str =
short_str.length() <= kProtobufOneLinerMaxLength ?
short_str : ("\n" + value.DebugString());
*os << ("<" + pretty_str + ">");
}
};
template <typename T>
class TypeWithoutFormatter<T, kConvertibleToInteger> {
public:
// Since T has no << operator or PrintTo() but can be implicitly
// converted to BiggestInt, we print it as a BiggestInt.
//
// Most likely T is an enum type (either named or unnamed), in which
// case printing it as an integer is the desired behavior. In case
// T is not an enum, printing it as an integer is the best we can do
// given that it has no user-defined printer.
static void PrintValue(const T& value, ::std::ostream* os) {
const internal::BiggestInt kBigInt = value;
*os << kBigInt;
}
};
// Prints the given value to the given ostream. If the value is a
// protocol message, its debug string is printed; if it's an enum or
// of a type implicitly convertible to BiggestInt, it's printed as an
// integer; otherwise the bytes in the value are printed. This is
// what UniversalPrinter<T>::Print() does when it knows nothing about
// type T and T has neither << operator nor PrintTo().
//
// A user can override this behavior for a class type Foo by defining
// a << operator in the namespace where Foo is defined.
//
// We put this operator in namespace 'internal2' instead of 'internal'
// to simplify the implementation, as much code in 'internal' needs to
// use << in STL, which would conflict with our own << were it defined
// in 'internal'.
//
// Note that this operator<< takes a generic std::basic_ostream<Char,
// CharTraits> type instead of the more restricted std::ostream. If
// we define it to take an std::ostream instead, we'll get an
// "ambiguous overloads" compiler error when trying to print a type
// Foo that supports streaming to std::basic_ostream<Char,
// CharTraits>, as the compiler cannot tell whether
// operator<<(std::ostream&, const T&) or
// operator<<(std::basic_stream<Char, CharTraits>, const Foo&) is more
// specific.
template <typename Char, typename CharTraits, typename T>
::std::basic_ostream<Char, CharTraits>& operator<<(
::std::basic_ostream<Char, CharTraits>& os, const T& x) {
TypeWithoutFormatter<T,
(internal::IsAProtocolMessage<T>::value ? kProtobuf :
internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
kConvertibleToInteger : kOtherType)>::PrintValue(x, &os);
return os;
}
} // namespace internal2
} // namespace testing
// This namespace MUST NOT BE NESTED IN ::testing, or the name look-up
// magic needed for implementing UniversalPrinter won't work.
namespace testing_internal {
// Used to print a value that is not an STL-style container when the
// user doesn't define PrintTo() for it.
template <typename T>
void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
// With the following statement, during unqualified name lookup,
// testing::internal2::operator<< appears as if it was declared in
// the nearest enclosing namespace that contains both
// ::testing_internal and ::testing::internal2, i.e. the global
// namespace. For more details, refer to the C++ Standard section
// 7.3.4-1 [namespace.udir]. This allows us to fall back onto
// testing::internal2::operator<< in case T doesn't come with a <<
// operator.
//
// We cannot write 'using ::testing::internal2::operator<<;', which
// gcc 3.3 fails to compile due to a compiler bug.
using namespace ::testing::internal2; // NOLINT
// Assuming T is defined in namespace foo, in the next statement,
// the compiler will consider all of:
//
// 1. foo::operator<< (thanks to Koenig look-up),
// 2. ::operator<< (as the current namespace is enclosed in ::),
// 3. testing::internal2::operator<< (thanks to the using statement above).
//
// The operator<< whose type matches T best will be picked.
//
// We deliberately allow #2 to be a candidate, as sometimes it's
// impossible to define #1 (e.g. when foo is ::std, defining
// anything in it is undefined behavior unless you are a compiler
// vendor.).
*os << value;
}
} // namespace testing_internal
namespace testing {
namespace internal {
// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given
// value to the given ostream. The caller must ensure that
// 'ostream_ptr' is not NULL, or the behavior is undefined.
//
// We define UniversalPrinter as a class template (as opposed to a
// function template), as we need to partially specialize it for
// reference types, which cannot be done with function templates.
template <typename T>
class UniversalPrinter;
template <typename T>
void UniversalPrint(const T& value, ::std::ostream* os);
// Used to print an STL-style container when the user doesn't define
// a PrintTo() for it.
template <typename C>
void DefaultPrintTo(IsContainer /* dummy */,
false_type /* is not a pointer */,
const C& container, ::std::ostream* os) {
const size_t kMaxCount = 32; // The maximum number of elements to print.
*os << '{';
size_t count = 0;
for (typename C::const_iterator it = container.begin();
it != container.end(); ++it, ++count) {
if (count > 0) {
*os << ',';
if (count == kMaxCount) { // Enough has been printed.
*os << " ...";
break;
}
}
*os << ' ';
// We cannot call PrintTo(*it, os) here as PrintTo() doesn't
// handle *it being a native array.
internal::UniversalPrint(*it, os);
}
if (count > 0) {
*os << ' ';
}
*os << '}';
}
// Used to print a pointer that is neither a char pointer nor a member
// pointer, when the user doesn't define PrintTo() for it. (A member
// variable pointer or member function pointer doesn't really point to
// a location in the address space. Their representation is
// implementation-defined. Therefore they will be printed as raw
// bytes.)
template <typename T>
void DefaultPrintTo(IsNotContainer /* dummy */,
true_type /* is a pointer */,
T* p, ::std::ostream* os) {
if (p == NULL) {
*os << "NULL";
} else {
// C++ doesn't allow casting from a function pointer to any object
// pointer.
//
// IsTrue() silences warnings: "Condition is always true",
// "unreachable code".
if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {
// T is not a function type. We just call << to print p,
// relying on ADL to pick up user-defined << for their pointer
// types, if any.
*os << p;
} else {
// T is a function type, so '*os << p' doesn't do what we want
// (it just prints p as bool). We want to print p as a const
// void*. However, we cannot cast it to const void* directly,
// even using reinterpret_cast, as earlier versions of gcc
// (e.g. 3.4.5) cannot compile the cast when p is a function
// pointer. Casting to UInt64 first solves the problem.
*os << reinterpret_cast<const void*>(
reinterpret_cast<internal::UInt64>(p));
}
}
}
// Used to print a non-container, non-pointer value when the user
// doesn't define PrintTo() for it.
template <typename T>
void DefaultPrintTo(IsNotContainer /* dummy */,
false_type /* is not a pointer */,
const T& value, ::std::ostream* os) {
::testing_internal::DefaultPrintNonContainerTo(value, os);
}
// Prints the given value using the << operator if it has one;
// otherwise prints the bytes in it. This is what
// UniversalPrinter<T>::Print() does when PrintTo() is not specialized
// or overloaded for type T.
//
// A user can override this behavior for a class type Foo by defining
// an overload of PrintTo() in the namespace where Foo is defined. We
// give the user this option as sometimes defining a << operator for
// Foo is not desirable (e.g. the coding style may prevent doing it,
// or there is already a << operator but it doesn't do what the user
// wants).
template <typename T>
void PrintTo(const T& value, ::std::ostream* os) {
// DefaultPrintTo() is overloaded. The type of its first two
// arguments determine which version will be picked. If T is an
// STL-style container, the version for container will be called; if
// T is a pointer, the pointer version will be called; otherwise the
// generic version will be called.
//
// Note that we check for container types here, prior to we check
// for protocol message types in our operator<<. The rationale is:
//
// For protocol messages, we want to give people a chance to
// override Google Mock's format by defining a PrintTo() or
// operator<<. For STL containers, other formats can be
// incompatible with Google Mock's format for the container
// elements; therefore we check for container types here to ensure
// that our format is used.
//
// The second argument of DefaultPrintTo() is needed to bypass a bug
// in Symbian's C++ compiler that prevents it from picking the right
// overload between:
//
// PrintTo(const T& x, ...);
// PrintTo(T* x, ...);
DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
}
// The following list of PrintTo() overloads tells
// UniversalPrinter<T>::Print() how to print standard types (built-in
// types, strings, plain arrays, and pointers).
// Overloads for various char types.
GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os);
GTEST_API_ void PrintTo(signed char c, ::std::ostream* os);
inline void PrintTo(char c, ::std::ostream* os) {
// When printing a plain char, we always treat it as unsigned. This
// way, the output won't be affected by whether the compiler thinks
// char is signed or not.
PrintTo(static_cast<unsigned char>(c), os);
}
// Overloads for other simple built-in types.
inline void PrintTo(bool x, ::std::ostream* os) {
*os << (x ? "true" : "false");
}
// Overload for wchar_t type.
// Prints a wchar_t as a symbol if it is printable or as its internal
// code otherwise and also as its decimal code (except for L'\0').
// The L'\0' char is printed as "L'\\0'". The decimal code is printed
// as signed integer when wchar_t is implemented by the compiler
// as a signed type and is printed as an unsigned integer when wchar_t
// is implemented as an unsigned type.
GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os);
// Overloads for C strings.
GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
inline void PrintTo(char* s, ::std::ostream* os) {
PrintTo(ImplicitCast_<const char*>(s), os);
}
// signed/unsigned char is often used for representing binary data, so
// we print pointers to it as void* to be safe.
inline void PrintTo(const signed char* s, ::std::ostream* os) {
PrintTo(ImplicitCast_<const void*>(s), os);
}
inline void PrintTo(signed char* s, ::std::ostream* os) {
PrintTo(ImplicitCast_<const void*>(s), os);
}
inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
PrintTo(ImplicitCast_<const void*>(s), os);
}
inline void PrintTo(unsigned char* s, ::std::ostream* os) {
PrintTo(ImplicitCast_<const void*>(s), os);
}
// MSVC can be configured to define wchar_t as a typedef of unsigned
// short. It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native
// type. When wchar_t is a typedef, defining an overload for const
// wchar_t* would cause unsigned short* be printed as a wide string,
// possibly causing invalid memory accesses.
#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
// Overloads for wide C strings
GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os);
inline void PrintTo(wchar_t* s, ::std::ostream* os) {
PrintTo(ImplicitCast_<const wchar_t*>(s), os);
}
#endif
// Overload for C arrays. Multi-dimensional arrays are printed
// properly.
// Prints the given number of elements in an array, without printing
// the curly braces.
template <typename T>
void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
UniversalPrint(a[0], os);
for (size_t i = 1; i != count; i++) {
*os << ", ";
UniversalPrint(a[i], os);
}
}
// Overloads for ::string and ::std::string.
#if GTEST_HAS_GLOBAL_STRING
GTEST_API_ void PrintStringTo(const ::string&s, ::std::ostream* os);
inline void PrintTo(const ::string& s, ::std::ostream* os) {
PrintStringTo(s, os);
}
#endif // GTEST_HAS_GLOBAL_STRING
GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);
inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
PrintStringTo(s, os);
}
// Overloads for ::wstring and ::std::wstring.
#if GTEST_HAS_GLOBAL_WSTRING
GTEST_API_ void PrintWideStringTo(const ::wstring&s, ::std::ostream* os);
inline void PrintTo(const ::wstring& s, ::std::ostream* os) {
PrintWideStringTo(s, os);
}
#endif // GTEST_HAS_GLOBAL_WSTRING
#if GTEST_HAS_STD_WSTRING
GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os);
inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
PrintWideStringTo(s, os);
}
#endif // GTEST_HAS_STD_WSTRING
#if GTEST_HAS_TR1_TUPLE
// Overload for ::std::tr1::tuple. Needed for printing function arguments,
// which are packed as tuples.
// Helper function for printing a tuple. T must be instantiated with
// a tuple type.
template <typename T>
void PrintTupleTo(const T& t, ::std::ostream* os);
// Overloaded PrintTo() for tuples of various arities. We support
// tuples of up-to 10 fields. The following implementation works
// regardless of whether tr1::tuple is implemented using the
// non-standard variadic template feature or not.
inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) {
PrintTupleTo(t, os);
}
template <typename T1>
void PrintTo(const ::std::tr1::tuple<T1>& t, ::std::ostream* os) {
PrintTupleTo(t, os);
}
template <typename T1, typename T2>
void PrintTo(const ::std::tr1::tuple<T1, T2>& t, ::std::ostream* os) {
PrintTupleTo(t, os);
}
template <typename T1, typename T2, typename T3>
void PrintTo(const ::std::tr1::tuple<T1, T2, T3>& t, ::std::ostream* os) {
PrintTupleTo(t, os);
}
template <typename T1, typename T2, typename T3, typename T4>
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4>& t, ::std::ostream* os) {
PrintTupleTo(t, os);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5>
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5>& t,
::std::ostream* os) {
PrintTupleTo(t, os);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6>
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6>& t,
::std::ostream* os) {
PrintTupleTo(t, os);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7>
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7>& t,
::std::ostream* os) {
PrintTupleTo(t, os);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8>
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8>& t,
::std::ostream* os) {
PrintTupleTo(t, os);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9>
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>& t,
::std::ostream* os) {
PrintTupleTo(t, os);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10>
void PrintTo(
const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& t,
::std::ostream* os) {
PrintTupleTo(t, os);
}
#endif // GTEST_HAS_TR1_TUPLE
// Overload for std::pair.
template <typename T1, typename T2>
void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {
*os << '(';
// We cannot use UniversalPrint(value.first, os) here, as T1 may be
// a reference type. The same for printing value.second.
UniversalPrinter<T1>::Print(value.first, os);
*os << ", ";
UniversalPrinter<T2>::Print(value.second, os);
*os << ')';
}
// Implements printing a non-reference type T by letting the compiler
// pick the right overload of PrintTo() for T.
template <typename T>
class UniversalPrinter {
public:
// MSVC warns about adding const to a function type, so we want to
// disable the warning.
#ifdef _MSC_VER
# pragma warning(push) // Saves the current warning state.
# pragma warning(disable:4180) // Temporarily disables warning 4180.
#endif // _MSC_VER
// Note: we deliberately don't call this PrintTo(), as that name
// conflicts with ::testing::internal::PrintTo in the body of the
// function.
static void Print(const T& value, ::std::ostream* os) {
// By default, ::testing::internal::PrintTo() is used for printing
// the value.
//
// Thanks to Koenig look-up, if T is a class and has its own
// PrintTo() function defined in its namespace, that function will
// be visible here. Since it is more specific than the generic ones
// in ::testing::internal, it will be picked by the compiler in the
// following statement - exactly what we want.
PrintTo(value, os);
}
#ifdef _MSC_VER
# pragma warning(pop) // Restores the warning state.
#endif // _MSC_VER
};
// UniversalPrintArray(begin, len, os) prints an array of 'len'
// elements, starting at address 'begin'.
template <typename T>
void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
if (len == 0) {
*os << "{}";
} else {
*os << "{ ";
const size_t kThreshold = 18;
const size_t kChunkSize = 8;
// If the array has more than kThreshold elements, we'll have to
// omit some details by printing only the first and the last
// kChunkSize elements.
// TODO(wan@google.com): let the user control the threshold using a flag.
if (len <= kThreshold) {
PrintRawArrayTo(begin, len, os);
} else {
PrintRawArrayTo(begin, kChunkSize, os);
*os << ", ..., ";
PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
}
*os << " }";
}
}
// This overload prints a (const) char array compactly.
GTEST_API_ void UniversalPrintArray(
const char* begin, size_t len, ::std::ostream* os);
// This overload prints a (const) wchar_t array compactly.
GTEST_API_ void UniversalPrintArray(
const wchar_t* begin, size_t len, ::std::ostream* os);
// Implements printing an array type T[N].
template <typename T, size_t N>
class UniversalPrinter<T[N]> {
public:
// Prints the given array, omitting some elements when there are too
// many.
static void Print(const T (&a)[N], ::std::ostream* os) {
UniversalPrintArray(a, N, os);
}
};
// Implements printing a reference type T&.
template <typename T>
class UniversalPrinter<T&> {
public:
// MSVC warns about adding const to a function type, so we want to
// disable the warning.
#ifdef _MSC_VER
# pragma warning(push) // Saves the current warning state.
# pragma warning(disable:4180) // Temporarily disables warning 4180.
#endif // _MSC_VER
static void Print(const T& value, ::std::ostream* os) {
// Prints the address of the value. We use reinterpret_cast here
// as static_cast doesn't compile when T is a function type.
*os << "@" << reinterpret_cast<const void*>(&value) << " ";
// Then prints the value itself.
UniversalPrint(value, os);
}
#ifdef _MSC_VER
# pragma warning(pop) // Restores the warning state.
#endif // _MSC_VER
};
// Prints a value tersely: for a reference type, the referenced value
// (but not the address) is printed; for a (const) char pointer, the
// NUL-terminated string (but not the pointer) is printed.
template <typename T>
class UniversalTersePrinter {
public:
static void Print(const T& value, ::std::ostream* os) {
UniversalPrint(value, os);
}
};
template <typename T>
class UniversalTersePrinter<T&> {
public:
static void Print(const T& value, ::std::ostream* os) {
UniversalPrint(value, os);
}
};
template <typename T, size_t N>
class UniversalTersePrinter<T[N]> {
public:
static void Print(const T (&value)[N], ::std::ostream* os) {
UniversalPrinter<T[N]>::Print(value, os);
}
};
template <>
class UniversalTersePrinter<const char*> {
public:
static void Print(const char* str, ::std::ostream* os) {
if (str == NULL) {
*os << "NULL";
} else {
UniversalPrint(string(str), os);
}
}
};
template <>
class UniversalTersePrinter<char*> {
public:
static void Print(char* str, ::std::ostream* os) {
UniversalTersePrinter<const char*>::Print(str, os);
}
};
#if GTEST_HAS_STD_WSTRING
template <>
class UniversalTersePrinter<const wchar_t*> {
public:
static void Print(const wchar_t* str, ::std::ostream* os) {
if (str == NULL) {
*os << "NULL";
} else {
UniversalPrint(::std::wstring(str), os);
}
}
};
#endif
template <>
class UniversalTersePrinter<wchar_t*> {
public:
static void Print(wchar_t* str, ::std::ostream* os) {
UniversalTersePrinter<const wchar_t*>::Print(str, os);
}
};
template <typename T>
void UniversalTersePrint(const T& value, ::std::ostream* os) {
UniversalTersePrinter<T>::Print(value, os);
}
// Prints a value using the type inferred by the compiler. The
// difference between this and UniversalTersePrint() is that for a
// (const) char pointer, this prints both the pointer and the
// NUL-terminated string.
template <typename T>
void UniversalPrint(const T& value, ::std::ostream* os) {
// A workarond for the bug in VC++ 7.1 that prevents us from instantiating
// UniversalPrinter with T directly.
typedef T T1;
UniversalPrinter<T1>::Print(value, os);
}
#if GTEST_HAS_TR1_TUPLE
typedef ::std::vector<string> Strings;
// This helper template allows PrintTo() for tuples and
// UniversalTersePrintTupleFieldsToStrings() to be defined by
// induction on the number of tuple fields. The idea is that
// TuplePrefixPrinter<N>::PrintPrefixTo(t, os) prints the first N
// fields in tuple t, and can be defined in terms of
// TuplePrefixPrinter<N - 1>.
// The inductive case.
template <size_t N>
struct TuplePrefixPrinter {
// Prints the first N fields of a tuple.
template <typename Tuple>
static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
TuplePrefixPrinter<N - 1>::PrintPrefixTo(t, os);
*os << ", ";
UniversalPrinter<typename ::std::tr1::tuple_element<N - 1, Tuple>::type>
::Print(::std::tr1::get<N - 1>(t), os);
}
// Tersely prints the first N fields of a tuple to a string vector,
// one element for each field.
template <typename Tuple>
static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
TuplePrefixPrinter<N - 1>::TersePrintPrefixToStrings(t, strings);
::std::stringstream ss;
UniversalTersePrint(::std::tr1::get<N - 1>(t), &ss);
strings->push_back(ss.str());
}
};
// Base cases.
template <>
struct TuplePrefixPrinter<0> {
template <typename Tuple>
static void PrintPrefixTo(const Tuple&, ::std::ostream*) {}
template <typename Tuple>
static void TersePrintPrefixToStrings(const Tuple&, Strings*) {}
};
// We have to specialize the entire TuplePrefixPrinter<> class
// template here, even though the definition of
// TersePrintPrefixToStrings() is the same as the generic version, as
// Embarcadero (formerly CodeGear, formerly Borland) C++ doesn't
// support specializing a method template of a class template.
template <>
struct TuplePrefixPrinter<1> {
template <typename Tuple>
static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
UniversalPrinter<typename ::std::tr1::tuple_element<0, Tuple>::type>::
Print(::std::tr1::get<0>(t), os);
}
template <typename Tuple>
static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
::std::stringstream ss;
UniversalTersePrint(::std::tr1::get<0>(t), &ss);
strings->push_back(ss.str());
}
};
// Helper function for printing a tuple. T must be instantiated with
// a tuple type.
template <typename T>
void PrintTupleTo(const T& t, ::std::ostream* os) {
*os << "(";
TuplePrefixPrinter< ::std::tr1::tuple_size<T>::value>::
PrintPrefixTo(t, os);
*os << ")";
}
// Prints the fields of a tuple tersely to a string vector, one
// element for each field. See the comment before
// UniversalTersePrint() for how we define "tersely".
template <typename Tuple>
Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
Strings result;
TuplePrefixPrinter< ::std::tr1::tuple_size<Tuple>::value>::
TersePrintPrefixToStrings(value, &result);
return result;
}
#endif // GTEST_HAS_TR1_TUPLE
} // namespace internal
template <typename T>
::std::string PrintToString(const T& value) {
::std::stringstream ss;
internal::UniversalTersePrinter<T>::Print(value, &ss);
return ss.str();
}
} // namespace testing
#endif // GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
================================================
FILE: libs/googleTest/1.7.0/include/gtest/gtest-spi.h
================================================
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: wan@google.com (Zhanyong Wan)
//
// Utilities for testing Google Test itself and code that uses Google Test
// (e.g. frameworks built on top of Google Test).
#ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_
#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_
#include "gtest/gtest.h"
namespace testing {
// This helper class can be used to mock out Google Test failure reporting
// so that we can test Google Test or code that builds on Google Test.
//
// An object of this class appends a TestPartResult object to the
// TestPartResultArray object given in the constructor whenever a Google Test
// failure is reported. It can either intercept only failures that are
// generated in the same thread that created this object or it can intercept
// all generated failures. The scope of this mock object can be controlled with
// the second argument to the two arguments constructor.
class GTEST_API_ ScopedFakeTestPartResultReporter
: public TestPartResultReporterInterface {
public:
// The two possible mocking modes of this object.
enum InterceptMode {
INTERCEPT_ONLY_CURRENT_THREAD, // Intercepts only thread local failures.
INTERCEPT_ALL_THREADS // Intercepts all failures.
};
// The c'tor sets this object as the test part result reporter used
// by Google Test. The 'result' parameter specifies where to report the
// results. This reporter will only catch failures generated in the current
// thread. DEPRECATED
explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);
// Same as above, but you can choose the interception scope of this object.
ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
TestPartResultArray* result);
// The d'tor restores the previous test part result reporter.
virtual ~ScopedFakeTestPartResultReporter();
// Appends the TestPartResult object to the TestPartResultArray
// received in the constructor.
//
// This method is from the TestPartResultReporterInterface
// interface.
virtual void ReportTestPartResult(const TestPartResult& result);
private:
void Init();
const InterceptMode intercept_mode_;
TestPartResultReporterInterface* old_reporter_;
TestPartResultArray* const result_;
GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
};
namespace internal {
// A helper class for implementing EXPECT_FATAL_FAILURE() and
// EXPECT_NONFATAL_FAILURE(). Its destructor verifies that the given
// TestPartResultArray contains exactly one failure that has the given
// type and contains the given substring. If that's not the case, a
// non-fatal failure will be generated.
class GTEST_API_ SingleFailureChecker {
public:
// The constructor remembers the arguments.
SingleFailureChecker(const TestPartResultArray* results,
TestPartResult::Type type,
const string& substr);
~SingleFailureChecker();
private:
const TestPartResultArray* const results_;
const TestPartResult::Type type_;
const string substr_;
GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
};
} // namespace internal
} // namespace testing
// A set of macros for testing Google Test assertions or code that's expected
// to generate Google Test fatal failures. It verifies that the given
// statement will cause exactly one fatal Google Test failure with 'substr'
// being part of the failure message.
//
// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
// affects and considers failures generated in the current thread and
// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
//
// The verification of the assertion is done correctly even when the statement
// throws an exception or aborts the current function.
//
// Known restrictions:
// - 'statement' cannot reference local non-static variables or
// non-static members of the current object.
// - 'statement' cannot return a value.
// - You cannot stream a failure message to this macro.
//
// Note that even though the implementations of the following two
// macros are much alike, we cannot refactor them to use a common
// helper macro, due to some peculiarity in how the preprocessor
// works. The AcceptsMacroThatExpandsToUnprotectedComma test in
// gtest_unittest.cc will fail to compile if we do that.
#define EXPECT_FATAL_FAILURE(statement, substr) \
do { \
class GTestExpectFatalFailureHelper {\
public:\
static void Execute() { statement; }\
};\
::testing::TestPartResultArray gtest_failures;\
::testing::internal::SingleFailureChecker gtest_checker(\
>est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
{\
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
::testing::ScopedFakeTestPartResultReporter:: \
INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\
GTestExpectFatalFailureHelper::Execute();\
}\
} while (::testing::internal::AlwaysFalse())
#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
do { \
class GTestExpectFatalFailureHelper {\
public:\
static void Execute() { statement; }\
};\
::testing::TestPartResultArray gtest_failures;\
::testing::internal::SingleFailureChecker gtest_checker(\
>est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
{\
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
::testing::ScopedFakeTestPartResultReporter:: \
INTERCEPT_ALL_THREADS, >est_failures);\
GTestExpectFatalFailureHelper::Execute();\
}\
} while (::testing::internal::AlwaysFalse())
// A macro for testing Google Test assertions or code that's expected to
// generate Google Test non-fatal failures. It asserts that the given
// statement will cause exactly one non-fatal Google Test failure with 'substr'
// being part of the failure message.
//
// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
// affects and considers failures generated in the current thread and
// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
//
// 'statement' is allowed to reference local variables and members of
// the current object.
//
// The verification of the assertion is done correctly even when the statement
// throws an exception or aborts the current function.
//
// Known restrictions:
// - You cannot stream a failure message to this macro.
//
// Note that even though the implementations of the following two
// macros are much alike, we cannot refactor them to use a common
// helper macro, due to some peculiarity in how the preprocessor
// works. If we do that, the code won't compile when the user gives
// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
// expands to code containing an unprotected comma. The
// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
// catches that.
//
// For the same reason, we have to write
// if (::testing::internal::AlwaysTrue()) { statement; }
// instead of
// GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
// to avoid an MSVC warning on unreachable code.
#define EXPECT_NONFATAL_FAILURE(statement, substr) \
do {\
::testing::TestPartResultArray gtest_failures;\
::testing::internal::SingleFailureChecker gtest_checker(\
>est_failures, ::testing::TestPartResult::kNonFatalFailure, \
(substr));\
{\
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
::testing::ScopedFakeTestPartResultReporter:: \
INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\
if (::testing::internal::AlwaysTrue()) { statement; }\
}\
} while (::testing::internal::AlwaysFalse())
#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
do {\
::testing::TestPartResultArray gtest_failures;\
::testing::internal::SingleFailureChecker gtest_checker(\
>est_failures, ::testing::TestPartResult::kNonFatalFailure, \
(substr));\
{\
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
>est_failures);\
if (::testing::internal::AlwaysTrue()) { statement; }\
}\
} while (::testing::internal::AlwaysFalse())
#endif // GTEST_INCLUDE_GTEST_GTEST_SPI_H_
================================================
FILE: libs/googleTest/1.7.0/include/gtest/gtest-test-part.h
================================================
// Copyright 2008, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: mheule@google.com (Markus Heule)
//
#ifndef GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
#define GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
#include <iosfwd>
#include <vector>
#include "gtest/internal/gtest-internal.h"
#include "gtest/internal/gtest-string.h"
namespace testing {
// A copyable object representing the result of a test part (i.e. an
// assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()).
//
// Don't inherit from TestPartResult as its destructor is not virtual.
class GTEST_API_ TestPartResult {
public:
// The possible outcomes of a test part (i.e. an assertion or an
// explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
enum Type {
kSuccess, // Succeeded.
kNonFatalFailure, // Failed but the test can continue.
kFatalFailure // Failed and the test should be terminated.
};
// C'tor. TestPartResult does NOT have a default constructor.
// Always use this constructor (with parameters) to create a
// TestPartResult object.
TestPartResult(Type a_type,
const char* a_file_name,
int a_line_number,
const char* a_message)
: type_(a_type),
file_name_(a_file_name == NULL ? "" : a_file_name),
line_number_(a_line_number),
summary_(ExtractSummary(a_message)),
message_(a_message) {
}
// Gets the outcome of the test part.
Type type() const { return type_; }
// Gets the name of the source file where the test part took place, or
// NULL if it's unknown.
const char* file_name() const {
return file_name_.empty() ? NULL : file_name_.c_str();
}
// Gets the line in the source file where the test part took place,
// or -1 if it's unknown.
int line_number() const { return line_number_; }
// Gets the summary of the failure message.
const char* summary() const { return summary_.c_str(); }
// Gets the message associated with the test part.
const char* message() const { return message_.c_str(); }
// Returns true iff the test part passed.
bool passed() const { return type_ == kSuccess; }
// Returns true iff the test part failed.
bool failed() const { return type_ != kSuccess; }
// Returns true iff the test part non-fatally failed.
bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
// Returns true iff the test part fatally failed.
bool fatally_failed() const { return type_ == kFatalFailure; }
private:
Type type_;
// Gets the summary of the failure message by omitting the stack
// trace in it.
static std::string ExtractSummary(const char* message);
// The name of the source file where the test part took place, or
// "" if the source file is unknown.
std::string file_name_;
// The line in the source file where the test part took place, or -1
// if the line number is unknown.
int line_number_;
std::string summary_; // The test failure summary.
std::string message_; // The test failure message.
};
// Prints a TestPartResult object.
std::ostream& operator<<(std::ostream& os, const TestPartResult& result);
// An array of TestPartResult objects.
//
// Don't inherit from TestPartResultArray as its destructor is not
// virtual.
class GTEST_API_ TestPartResultArray {
public:
TestPartResultArray() {}
// Appends the given TestPartResult to the array.
void Append(const TestPartResult& result);
// Returns the TestPartResult at the given index (0-based).
const TestPartResult& GetTestPartResult(int index) const;
// Returns the number of TestPartResult objects in the array.
int size() const;
private:
std::vector<TestPartResult> array_;
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray);
};
// This interface knows how to report a test part result.
class TestPartResultReporterInterface {
public:
virtual ~TestPartResultReporterInterface() {}
virtual void ReportTestPartResult(const TestPartResult& result) = 0;
};
namespace internal {
// This helper class is used by {ASSERT|EXPECT}_NO_FATAL_FAILURE to check if a
// statement generates new fatal failures. To do so it registers itself as the
// current test part result reporter. Besides checking if fatal failures were
// reported, it only delegates the reporting to the former result reporter.
// The original result reporter is restored in the destructor.
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
class GTEST_API_ HasNewFatalFailureHelper
: public TestPartResultReporterInterface {
public:
HasNewFatalFailureHelper();
virtual ~HasNewFatalFailureHelper();
virtual void ReportTestPartResult(const TestPartResult& result);
bool has_new_fatal_failure() const { return has_new_fatal_failure_; }
private:
bool has_new_fatal_failure_;
TestPartResultReporterInterface* original_reporter_;
GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper);
};
} // namespace internal
} // namespace testing
#endif // GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
================================================
FILE: libs/googleTest/1.7.0/include/gtest/gtest-typed-test.h
================================================
// Copyright 2008 Google Inc.
// All Rights Reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: wan@google.com (Zhanyong Wan)
#ifndef GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
#define GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
// This header implements typed tests and type-parameterized tests.
// Typed (aka type-driven) tests repeat the same test for types in a
// list. You must know which types you want to test with when writing
// typed tests. Here's how you do it:
#if 0
// First, define a fixture class template. It should be parameterized
// by a type. Remember to derive it from testing::Test.
template <typename T>
class FooTest : public testing::Test {
public:
...
typedef std::list<T> List;
static T shared_;
T value_;
};
// Next, associate a list of types with the test case, which will be
// repeated for each type in the list. The typedef is necessary for
// the macro to parse correctly.
typedef testing::Types<char, int, unsigned int> MyTypes;
TYPED_TEST_CASE(FooTest, MyTypes);
// If the type list contains only one type, you can write that type
// directly without Types<...>:
// TYPED_TEST_CASE(FooTest, int);
// Then, use TYPED_TEST() instead of TEST_F() to define as many typed
// tests for this test case as you want.
TYPED_TEST(FooTest, DoesBlah) {
// Inside a test, refer to TypeParam to get the type parameter.
// Since we are inside a derived class template, C++ requires use to
// visit the members of FooTest via 'this'.
TypeParam n = this->value_;
// To visit static members of the fixture, add the TestFixture::
// prefix.
n += TestFixture::shared_;
// To refer to typedefs in the fixture, add the "typename
// TestFixture::" prefix.
typename TestFixture::List values;
values.push_back(n);
...
}
TYPED_TEST(FooTest, HasPropertyA) { ... }
#endif // 0
// Type-parameterized tests are abstract test patterns parameterized
// by a type. Compared with typed tests, type-parameterized tests
// allow you to define the test pattern without knowing what the type
// parameters are. The defined pattern can be instantiated with
// different types any number of times, in any number of translation
// units.
//
// If you are designing an interface or concept, you can define a
// suite of type-parameterized tests to verify properties that any
// valid implementation of the interface/concept should have. Then,
// each implementation can easily instantiate the test suite to verify
// that it conforms to the requirements, without having to write
// similar tests repeatedly. Here's an example:
#if 0
// First, define a fixture class template. It should be parameterized
// by a type. Remember to derive it from testing::Test.
template <typename T>
class FooTest : public testing::Test {
...
};
// Next, declare that you will define a type-parameterized test case
// (the _P suffix is for "parameterized" or "pattern", whichever you
// prefer):
TYPED_TEST_CASE_P(FooTest);
// Then, use TYPED_TEST_P() to define as many type-parameterized tests
// for this type-parameterized test case as you want.
TYPED_TEST_P(FooTest, DoesBlah) {
// Inside a test, refer to TypeParam to get the type parameter.
TypeParam n = 0;
...
}
TYPED_TEST_P(FooTest, HasPropertyA) { ... }
// Now the tricky part: you need to register all test patterns before
// you can instantiate them. The first argument of the macro is the
// test case name; the rest are the names of the tests in this test
// case.
REGISTER_TYPED_TEST_CASE_P(FooTest,
DoesBlah, HasPropertyA);
// Finally, you are free to instantiate the pattern with the types you
// want. If you put the above code in a header file, you can #include
// it in multiple C++ source files and instantiate it multiple times.
//
// To distinguish different instances of the pattern, the first
// argument to the INSTANTIATE_* macro is a prefix that will be added
// to the actual test case name. Remember to pick unique prefixes for
// different instances.
typedef testing::Types<char, int, unsigned int> MyTypes;
INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
// If the type list contains only one type, you can write that type
// directly without Types<...>:
// INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
#endif // 0
#include "gtest/internal/gtest-port.h"
#include "gtest/internal/gtest-type-util.h"
// Implements typed tests.
#if GTEST_HAS_TYPED_TEST
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// Expands to the name of the typedef for the type parameters of the
// given test case.
# define GTEST_TYPE_PARAMS_(TestCaseName) gtest_type_params_##TestCaseName##_
// The 'Types' template argument below must have spaces around it
// since some compilers may choke on '>>' when passing a template
// instance (e.g. Types<int>)
# define TYPED_TEST_CASE(CaseName, Types) \
typedef ::testing::internal::TypeList< Types >::type \
GTEST_TYPE_PARAMS_(CaseName)
# define TYPED_TEST(CaseName, TestName) \
template <typename gtest_TypeParam_> \
class GTEST_TEST_CLASS_NAME_(CaseName, TestName) \
: public CaseName<gtest_TypeParam_> { \
private: \
typedef CaseName<gtest_TypeParam_> TestFixture; \
typedef gtest_TypeParam_ TypeParam; \
virtual void TestBody(); \
}; \
bool gtest_##CaseName##_##TestName##_registered_ GTEST_ATTRIBUTE_UNUSED_ = \
::testing::internal::TypeParameterizedTest< \
CaseName, \
::testing::internal::TemplateSel< \
GTEST_TEST_CLASS_NAME_(CaseName, TestName)>, \
GTEST_TYPE_PARAMS_(CaseName)>::Register(\
"", #CaseName, #TestName, 0); \
template <typename gtest_TypeParam_> \
void GTEST_TEST_CLASS_NAME_(CaseName, TestName)<gtest_TypeParam_>::TestBody()
#endif // GTEST_HAS_TYPED_TEST
// Implements type-parameterized tests.
#if GTEST_HAS_TYPED_TEST_P
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// Expands to the namespace name that the type-parameterized tests for
// the given type-parameterized test case are defined in. The exact
// name of the namespace is subject to change without notice.
# define GTEST_CASE_NAMESPACE_(TestCaseName) \
gtest_case_##TestCaseName##_
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// Expands to the name of the variable used to remember the names of
// the defined tests in the given test case.
# define GTEST_TYPED_TEST_CASE_P_STATE_(TestCaseName) \
gtest_typed_test_case_p_state_##TestCaseName##_
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY.
//
// Expands to the name of the variable used to remember the names of
// the registered tests in the given test case.
# define GTEST_REGISTERED_TEST_NAMES_(TestCaseName) \
gtest_registered_test_names_##TestCaseName##_
// The variables defined in the type-parameterized test macros are
// static as typically these macros are used in a .h file that can be
// #included in multiple translation units linked together.
# define TYPED_TEST_CASE_P(CaseName) \
static ::testing::internal::TypedTestCasePState \
GTEST_TYPED_TEST_CASE_P_STATE_(CaseName)
# define TYPED_TEST_P(CaseName, TestName) \
namespace GTEST_CASE_NAMESPACE_(CaseName) { \
template <typename gtest_TypeParam_> \
class TestName : public CaseName<gtest_TypeParam_> { \
private: \
typedef CaseName<gtest_TypeParam_> TestFixture; \
typedef gtest_TypeParam_ TypeParam; \
virtual void TestBody(); \
}; \
static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).AddTestName(\
__FILE__, __LINE__, #CaseName, #TestName); \
} \
template <typename gtest_TypeParam_> \
void GTEST_CASE_NAMESPACE_(CaseName)::TestName<gtest_TypeParam_>::TestBody()
# define REGISTER_TYPED_TEST_CASE_P(CaseName, ...) \
namespace GTEST_CASE_NAMESPACE_(CaseName) { \
typedef ::testing::internal::Templates<__VA_ARGS__>::type gtest_AllTests_; \
} \
static const char* const GTEST_REGISTERED_TEST_NAMES_(CaseName) = \
GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).VerifyRegisteredTestNames(\
__FILE__, __LINE__, #__VA_ARGS__)
// The 'Types' template argument below must have spaces around it
// since some compilers may choke on '>>' when passing a template
// instance (e.g. Types<int>)
# define INSTANTIATE_TYPED_TEST_CASE_P(Prefix, CaseName, Types) \
bool gtest_##Prefix##_##CaseName GTEST_ATTRIBUTE_UNUSED_ = \
::testing::internal::TypeParameterizedTestCase<CaseName, \
GTEST_CASE_NAMESPACE_(CaseName)::gtest_AllTests_, \
::testing::internal::TypeList< Types >::type>::Register(\
#Prefix, #CaseName, GTEST_REGISTERED_TEST_NAMES_(CaseName))
#endif // GTEST_HAS_TYPED_TEST_P
#endif // GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
================================================
FILE: libs/googleTest/1.7.0/include/gtest/gtest.h
================================================
// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: wan@google.com (Zhanyong Wan)
//
// The Google C++ Testing Framework (Google Test)
//
// This header file defines the public API for Google Test. It should be
// included by any test program that uses Google Test.
//
// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
// leave some internal implementation details in this header file.
// They are clearly marked by comments like this:
//
// // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
//
// Such code is NOT meant to be used by a user directly, and is subject
// to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a
gitextract_u9fmdbai/
├── .classpath
├── .gitignore
├── .project
├── .travis.yml
├── LICENSE
├── README.md
├── build.gradle
├── docs/
│ └── DEVOXX_2017_De_bronze_a_legendaire_comment_reussir_vos_IA_de_Bot.pptx
├── libs/
│ └── googleTest/
│ └── 1.7.0/
│ ├── include/
│ │ └── gtest/
│ │ ├── gtest-death-test.h
│ │ ├── gtest-message.h
│ │ ├── gtest-param-test.h
│ │ ├── gtest-param-test.h.pump
│ │ ├── gtest-printers.h
│ │ ├── gtest-spi.h
│ │ ├── gtest-test-part.h
│ │ ├── gtest-typed-test.h
│ │ ├── gtest.h
│ │ ├── gtest_pred_impl.h
│ │ ├── gtest_prod.h
│ │ └── internal/
│ │ ├── gtest-death-test-internal.h
│ │ ├── gtest-filepath.h
│ │ ├── gtest-internal.h
│ │ ├── gtest-linked_ptr.h
│ │ ├── gtest-param-util-generated.h
│ │ ├── gtest-param-util-generated.h.pump
│ │ ├── gtest-param-util.h
│ │ ├── gtest-port.h
│ │ ├── gtest-string.h
│ │ ├── gtest-tuple.h
│ │ ├── gtest-tuple.h.pump
│ │ ├── gtest-type-util.h
│ │ └── gtest-type-util.h.pump
│ └── lib/
│ ├── cygwin/
│ │ └── gtest.lib
│ ├── linux/
│ │ └── libgtest.a
│ ├── mingw/
│ │ └── gtest.lib
│ ├── osx/
│ │ └── libgtest.a
│ ├── vs2010/
│ │ └── gtest.lib
│ ├── vs2013/
│ │ └── gtest.lib
│ └── vs2015/
│ └── gtest.lib
├── settings.gradle
└── src/
├── competitiveProgramming/
│ └── headers/
│ ├── FileBuilderSample.hpp
│ └── competitive/
│ └── programming/
│ ├── gametheory/
│ │ ├── Common.hpp
│ │ ├── TreeNode.hpp
│ │ ├── maxntree/
│ │ │ └── MaxNTree.hpp
│ │ ├── minimax/
│ │ │ └── Minimax.hpp
│ │ └── treeSearch/
│ │ └── TreeSearch.hpp
│ ├── genetic/
│ │ └── GeneticAlgorithm.hpp
│ ├── geometry/
│ │ └── Point.hpp
│ ├── graph/
│ │ └── Graph.hpp
│ ├── math/
│ │ ├── Complex.hpp
│ │ └── QuadraticEquation.hpp
│ ├── physics/
│ │ └── Disk.hpp
│ └── timemanagement/
│ └── Timer.hpp
├── competitiveProgrammingTest/
│ └── cpp/
│ ├── competitive/
│ │ └── programming/
│ │ ├── gametheory/
│ │ │ └── TreesTest.cpp
│ │ ├── genetic/
│ │ │ └── GeneticAlgorithmTest.cpp
│ │ ├── geometry/
│ │ │ └── PointTest.cpp
│ │ ├── graph/
│ │ │ └── GraphTest.cpp
│ │ ├── math/
│ │ │ └── QuadraticEquationTest.cpp
│ │ ├── physics/
│ │ │ └── DiskTest.cpp
│ │ └── timemanagement/
│ │ └── TimerTest.cpp
│ └── test_main.cpp
├── main/
│ └── java/
│ ├── builder/
│ │ ├── FileBuilder.java
│ │ └── sample/
│ │ └── Sample.java
│ └── competitive/
│ └── programming/
│ ├── common/
│ │ └── Constants.java
│ ├── containers/
│ │ └── Pair.java
│ ├── gametheory/
│ │ ├── ICancellableMove.java
│ │ ├── IGame.java
│ │ ├── IMove.java
│ │ ├── IMoveGenerator.java
│ │ ├── common/
│ │ │ ├── IScoreConverter.java
│ │ │ ├── TreeNode.java
│ │ │ └── TreeNodeSorter.java
│ │ ├── maxntree/
│ │ │ └── MaxNTree.java
│ │ ├── minimax/
│ │ │ └── Minimax.java
│ │ └── treesearch/
│ │ └── TreeSearch.java
│ ├── genetic/
│ │ ├── CandidateGenerator.java
│ │ ├── CandidateMerger.java
│ │ ├── CandidateMutator.java
│ │ ├── FitnessFunction.java
│ │ └── GeneticAlgorithm.java
│ ├── geometry/
│ │ ├── Coord.java
│ │ └── Vector.java
│ ├── graph/
│ │ ├── Graph.java
│ │ ├── IBFSTraversable.java
│ │ ├── IDoubleBfsNextLevelValueIterator.java
│ │ └── IIntegerBfsNextValueIterator.java
│ ├── math/
│ │ ├── Complex.java
│ │ └── QuadraticEquation.java
│ ├── physics/
│ │ └── Disk.java
│ └── timemanagement/
│ ├── TimeoutException.java
│ └── Timer.java
└── test/
└── java/
└── competitive/
└── programming/
├── gametheory/
│ ├── StickGame.java
│ ├── StickGenerator.java
│ ├── StickMove.java
│ ├── Tester.java
│ ├── maxntree/
│ │ └── MaxNTreeTest.java
│ ├── minimax/
│ │ └── MinimaxTest.java
│ └── treesearch/
│ └── TreeSearchTest.java
├── genetic/
│ └── GeneticAlgorithmTest.java
├── geometry/
│ ├── CoordTest.java
│ └── VectorTest.java
├── graph/
│ └── GraphTest.java
├── math/
│ └── QuadraticEquationTest.java
├── physics/
│ └── DiskTest.java
└── timemanagement/
└── TimerTest.java
SYMBOL INDEX (801 symbols across 83 files)
FILE: libs/googleTest/1.7.0/include/gtest/gtest-death-test.h
function namespace (line 43) | namespace testing {
FILE: libs/googleTest/1.7.0/include/gtest/gtest-message.h
function namespace (line 57) | namespace testing {
function StreamHelper (line 206) | void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) {
function StreamHelper (line 214) | void StreamHelper(internal::false_type /*is_pointer*/,
function namespace (line 236) | namespace internal {
FILE: libs/googleTest/1.7.0/include/gtest/gtest-param-test.h
function class (line 162) | class BaseTest : public ::testing::Test {
function namespace (line 197) | namespace testing {
function internal (line 1220) | inline internal::ParamGenerator<bool> Bool() {
FILE: libs/googleTest/1.7.0/include/gtest/gtest-printers.h
function namespace (line 106) | namespace testing {
function namespace (line 213) | namespace testing_internal {
function namespace (line 250) | namespace testing {
function PrintTo (line 458) | inline void PrintTo(const ::string& s, ::std::ostream* os) {
function PrintTo (line 464) | inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
function PrintTo (line 471) | inline void PrintTo(const ::wstring& s, ::std::ostream* os) {
function PrintTo (line 478) | inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
function PrintTo (line 497) | inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) {
function Print (line 591) | static void Print(const T& value, ::std::ostream* os) {
function Print (line 662) | static void Print(const T& value, ::std::ostream* os) {
function Print (line 704) | static void Print(const char* str, ::std::ostream* os) {
FILE: libs/googleTest/1.7.0/include/gtest/gtest-spi.h
function namespace (line 40) | namespace testing {
FILE: libs/googleTest/1.7.0/include/gtest/gtest-test-part.h
function namespace (line 41) | namespace testing {
function class (line 126) | class GTEST_API_ TestPartResultArray {
function class (line 146) | class TestPartResultReporterInterface {
function namespace (line 153) | namespace internal {
FILE: libs/googleTest/1.7.0/include/gtest/gtest-typed-test.h
type testing (line 57) | typedef testing::Types<char, int, unsigned int> MyTypes;
type testing (line 140) | typedef testing::Types<char, int, unsigned int> MyTypes;
FILE: libs/googleTest/1.7.0/include/gtest/gtest.h
function namespace (line 83) | namespace testing {
function namespace (line 1676) | namespace internal {
function class (line 1723) | class GTEST_API_ AssertHelper {
function virtual (line 1803) | virtual ~WithParamInterface() {}
FILE: libs/googleTest/1.7.0/include/gtest/internal/gtest-death-test-internal.h
function namespace (line 44) | namespace testing {
FILE: libs/googleTest/1.7.0/include/gtest/internal/gtest-filepath.h
function namespace (line 45) | namespace testing {
FILE: libs/googleTest/1.7.0/include/gtest/internal/gtest-internal.h
function namespace (line 77) | namespace proto2 { class Message; }
function namespace (line 79) | namespace testing {
type IsContainer (line 859) | typedef int IsContainer;
type IsNotContainer (line 867) | typedef char IsNotContainer;
function IsContainerTest (line 869) | IsContainerTest(long /* dummy */) { return '\0'; }
type EnableIf (line 876) | struct EnableIf
type type (line 876) | typedef void type;
function ArrayEq (line 889) | bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; }
function ArrayEq (line 893) | bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
function CopyArray (line 929) | void CopyArray(const T& from, U* to) { *to = from; }
function CopyArray (line 933) | void CopyArray(const T(&from)[N], U(*to)[N]) {
type RelationToSource (line 949) | enum RelationToSource {
type Element (line 968) | typedef Element* iterator;
type Element (line 969) | typedef const Element* const_iterator;
FILE: libs/googleTest/1.7.0/include/gtest/internal/gtest-linked_ptr.h
function namespace (line 76) | namespace testing {
function T (line 172) | T* get() const { return value_; }
function depart (line 194) | void depart() {
function capture (line 198) | void capture(T* ptr) {
FILE: libs/googleTest/1.7.0/include/gtest/internal/gtest-param-util-generated.h
function namespace (line 57) | namespace testing {
function virtual (line 3167) | virtual ~CartesianProductGenerator2() {}
function virtual (line 3169) | virtual ParamIteratorInterface<ParamType>* Begin() const {
function virtual (line 3172) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 3189) | virtual ~Iterator() {}
function virtual (line 3191) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 3196) | virtual void Advance() {
function virtual (line 3205) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 3208) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 3209) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 3238) | void ComputeCurrentValue() {
function virtual (line 3282) | virtual ~CartesianProductGenerator3() {}
function virtual (line 3284) | virtual ParamIteratorInterface<ParamType>* Begin() const {
function virtual (line 3288) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 3308) | virtual ~Iterator() {}
function virtual (line 3310) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 3315) | virtual void Advance() {
function virtual (line 3328) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 3331) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 3332) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 3365) | void ComputeCurrentValue() {
function virtual (line 3415) | virtual ~CartesianProductGenerator4() {}
function virtual (line 3417) | virtual ParamIteratorInterface<ParamType>* Begin() const {
function virtual (line 3421) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 3445) | virtual ~Iterator() {}
function virtual (line 3447) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 3452) | virtual void Advance() {
function virtual (line 3469) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 3472) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 3473) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 3510) | void ComputeCurrentValue() {
function virtual (line 3566) | virtual ~CartesianProductGenerator5() {}
function virtual (line 3568) | virtual ParamIteratorInterface<ParamType>* Begin() const {
function virtual (line 3572) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 3599) | virtual ~Iterator() {}
function virtual (line 3601) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 3606) | virtual void Advance() {
function virtual (line 3627) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 3630) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 3631) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 3672) | void ComputeCurrentValue() {
type std (line 3729) | typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> ParamType;
function virtual (line 3736) | virtual ~CartesianProductGenerator6() {}
function virtual (line 3738) | virtual ParamIteratorInterface<ParamType>* Begin() const {
function virtual (line 3742) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 3772) | virtual ~Iterator() {}
function virtual (line 3774) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 3779) | virtual void Advance() {
function virtual (line 3804) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 3807) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 3808) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 3853) | void ComputeCurrentValue() {
type std (line 3915) | typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7> ParamType;
function virtual (line 3922) | virtual ~CartesianProductGenerator7() {}
function virtual (line 3924) | virtual ParamIteratorInterface<ParamType>* Begin() const {
function virtual (line 3929) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 3962) | virtual ~Iterator() {}
function virtual (line 3964) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 3969) | virtual void Advance() {
function virtual (line 3998) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 4001) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 4002) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 4051) | void ComputeCurrentValue() {
type std (line 4118) | typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8> ParamType;
function virtual (line 4134) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 4171) | virtual ~Iterator() {}
function virtual (line 4173) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 4178) | virtual void Advance() {
function virtual (line 4211) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 4214) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 4215) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 4268) | void ComputeCurrentValue() {
type std (line 4340) | typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> ParamType;
function virtual (line 4356) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 4396) | virtual ~Iterator() {}
function virtual (line 4398) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 4403) | virtual void Advance() {
function virtual (line 4440) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 4443) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 4444) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 4501) | void ComputeCurrentValue() {
type std (line 4579) | typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Param...
function virtual (line 4596) | virtual ParamIteratorInterface<ParamType>* End() const {
function virtual (line 4639) | virtual ~Iterator() {}
function virtual (line 4641) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
function virtual (line 4646) | virtual void Advance() {
function virtual (line 4687) | virtual ParamIteratorInterface<ParamType>* Clone() const {
function virtual (line 4690) | virtual const ParamType* Current() const { return ¤t_value_; }
function virtual (line 4691) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
function ComputeCurrentValue (line 4752) | void ComputeCurrentValue() {
FILE: libs/googleTest/1.7.0/include/gtest/internal/gtest-param-util.h
function namespace (line 51) | namespace testing {
function CalculateEndIndex (line 242) | static int CalculateEndIndex(const T& begin,
function virtual (line 273) | virtual ~ValuesInIteratorRangeGenerator() {}
function virtual (line 275) | virtual ParamIteratorInterface<T>* Begin() const {
function virtual (line 278) | virtual ParamIteratorInterface<T>* End() const {
function class (line 285) | class Iterator : public ParamIteratorInterface<T> {
function explicit (line 356) | explicit ParameterizedTestFactory(ParamType parameter) :
function virtual (line 358) | virtual Test* CreateTest() {
function virtual (line 397) | virtual TestFactoryBase* CreateTestFactory(ParamType parameter) {
function class (line 415) | class ParameterizedTestCaseInfoBase {
type ParamGenerator (line 451) | typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
function explicit (line 453) | explicit ParameterizedTestCaseInfo(const char* name)
function AddTestPattern (line 466) | void AddTestPattern(const char* test_case_name,
function AddTestCaseInstantiation (line 475) | int AddTestCaseInstantiation(const string& instantiation_name,
function virtual (line 487) | virtual void RegisterTests() {
type TestInfo (line 525) | struct TestInfo {
type std (line 537) | typedef ::std::vector<linked_ptr<TestInfo> > TestInfoContainer;
type std (line 540) | typedef ::std::vector<std::pair<string, GeneratorCreationFunc*> >
function class (line 556) | class ParameterizedTestCaseRegistry {
FILE: libs/googleTest/1.7.0/include/gtest/internal/gtest-port.h
function namespace (line 553) | namespace std {
function namespace (line 785) | namespace testing {
function LogToStderr (line 1043) | inline void LogToStderr() {}
function FlushInfoLog (line 1044) | inline void FlushInfoLog() { fflush(NULL); }
function To (line 1098) | To ImplicitCast_(To x) { return x; }
function To (line 1122) | To DownCast_(From* f) { // so we only accept pointers
function SleepMilliseconds (line 1188) | inline void SleepMilliseconds(int n) {
function class (line 1202) | class Notification {
function class (line 1244) | class ThreadWithParamBase {
function Join (line 1292) | void Join() {
function virtual (line 1299) | virtual void Run() {
function class (line 1336) | class MutexBase {
function class (line 1394) | class Mutex : public MutexBase {
function class (line 1411) | class GTestMutexLock {
type GTestMutexLock (line 1424) | typedef GTestMutexLock MutexLock;
function class (line 1432) | class ThreadLocalValueHolderBase {
function DeleteThreadLocalValue (line 1439) | inline void DeleteThreadLocalValue(void* value_holder) {
function explicit (line 1477) | explicit ThreadLocal(const T& value) : key_(CreateKey()),
function T (line 1489) | T* pointer() { return GetOrCreateValue(); }
function T (line 1490) | const T* pointer() const { return GetOrCreateValue(); }
function set (line 1492) | void set(const T& value) { *pointer() = value; }
function T (line 1500) | T* pointer() { return &value_; }
function pthread_key_t (line 1507) | static pthread_key_t CreateKey() {
function T (line 1516) | T* GetOrCreateValue() const {
function class (line 1545) | class Mutex {
function class (line 1558) | class GTestMutexLock {
type GTestMutexLock (line 1563) | typedef GTestMutexLock MutexLock;
function explicit (line 1569) | explicit ThreadLocal(const T& value) : value_(value) {}
function T (line 1570) | T* pointer() { return &value_; }
function T (line 1571) | const T* pointer() const { return &value_; }
function set (line 1573) | void set(const T& value) { value_ = value; }
type bool_constant (line 1612) | typedef bool_constant<bool_value> type;
type bool_constant (line 1617) | typedef bool_constant<false> false_type;
type bool_constant (line 1618) | typedef bool_constant<true> true_type;
type typename (line 1628) | typedef typename Iterator::value_type value_type;
type T (line 1633) | typedef T value_type;
type T (line 1638) | typedef T value_type;
type __int64 (line 1645) | typedef __int64 BiggestInt;
type BiggestInt (line 1649) | typedef long long BiggestInt;
function IsAlpha (line 1659) | inline bool IsAlpha(char ch) {
function IsAlNum (line 1662) | inline bool IsAlNum(char ch) {
function IsDigit (line 1665) | inline bool IsDigit(char ch) {
function IsLower (line 1668) | inline bool IsLower(char ch) {
function IsSpace (line 1671) | inline bool IsSpace(char ch) {
function IsUpper (line 1674) | inline bool IsUpper(char ch) {
function IsXDigit (line 1677) | inline bool IsXDigit(char ch) {
function IsXDigit (line 1680) | inline bool IsXDigit(wchar_t ch) {
function ToLower (line 1685) | inline char ToLower(char ch) {
function ToUpper (line 1688) | inline char ToUpper(char ch) {
function namespace (line 1698) | namespace posix {
type UInt (line 1883) | typedef unsigned int UInt;
type __int64 (line 1891) | typedef __int64 Int;
type UInt (line 1892) | typedef unsigned __int64 UInt;
type Int (line 1894) | typedef long long Int;
type UInt (line 1895) | typedef unsigned long long UInt;
type TypeWithSize (line 1900) | typedef TypeWithSize<4>::Int Int32;
type TypeWithSize (line 1901) | typedef TypeWithSize<4>::UInt UInt32;
type TypeWithSize (line 1902) | typedef TypeWithSize<8>::Int Int64;
type TypeWithSize (line 1903) | typedef TypeWithSize<8>::UInt UInt64;
type TypeWithSize (line 1904) | typedef TypeWithSize<8>::Int TimeInMillis;
FILE: libs/googleTest/1.7.0/include/gtest/internal/gtest-string.h
function namespace (line 54) | namespace testing {
FILE: libs/googleTest/1.7.0/include/gtest/internal/gtest-tuple.h
function namespace (line 104) | namespace std {
function GTEST_1_TUPLE_ (line 205) | GTEST_1_TUPLE_(T) {
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 225) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 266) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 301) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 340) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 382) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 427) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 474) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 524) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 576) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 632) | GTEST_DECLARE_TUPLE_AS_FRIEND_
function make_tuple (line 675) | GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) {
function make_tuple (line 680) | GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) {
function make_tuple (line 685) | GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
function make_tuple (line 691) | GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
function make_tuple (line 697) | GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
function make_tuple (line 703) | GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
function make_tuple (line 709) | GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
function make_tuple (line 715) | GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
function make_tuple (line 722) | GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
type typename (line 789) | typedef typename gtest_internal::TupleElement<
function namespace (line 797) | namespace gtest_internal {
function namespace (line 937) | namespace gtest_internal {
FILE: libs/googleTest/1.7.0/include/gtest/internal/gtest-type-util.h
function namespace (line 57) | namespace testing {
type internal (line 754) | typedef internal::Types50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, ...
type Types (line 761) | struct Types
type internal (line 790) | typedef internal::Types1<T1> type;
type internal (line 806) | typedef internal::Types2<T1, T2> type;
type internal (line 821) | typedef internal::Types3<T1, T2, T3> type;
type internal (line 836) | typedef internal::Types4<T1, T2, T3, T4> type;
type internal (line 851) | typedef internal::Types5<T1, T2, T3, T4, T5> type;
type internal (line 867) | typedef internal::Types6<T1, T2, T3, T4, T5, T6> type;
type internal (line 883) | typedef internal::Types7<T1, T2, T3, T4, T5, T6, T7> type;
type internal (line 898) | typedef internal::Types8<T1, T2, T3, T4, T5, T6, T7, T8> type;
type internal (line 913) | typedef internal::Types9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type;
function namespace (line 1620) | namespace internal {
type Templates4 (line 1690) | typedef Templates4<T2, T3, T4, T5> Tail;
type Templates5 (line 1697) | typedef Templates5<T2, T3, T4, T5, T6> Tail;
type Templates6 (line 1705) | typedef Templates6<T2, T3, T4, T5, T6, T7> Tail;
type Templates7 (line 1713) | typedef Templates7<T2, T3, T4, T5, T6, T7, T8> Tail;
type Templates8 (line 1721) | typedef Templates8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
type Templates9 (line 1730) | typedef Templates9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
type Templates10 (line 1739) | typedef Templates10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
type Templates11 (line 1748) | typedef Templates11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail;
type Templates12 (line 1758) | typedef Templates12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> ...
type Templates13 (line 1768) | typedef Templates13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
type Templates14 (line 1779) | typedef Templates14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates15 (line 1791) | typedef Templates15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates16 (line 1803) | typedef Templates16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates17 (line 1815) | typedef Templates17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates18 (line 1828) | typedef Templates18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates19 (line 1841) | typedef Templates19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates20 (line 1854) | typedef Templates20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates21 (line 1868) | typedef Templates21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates22 (line 1882) | typedef Templates22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates23 (line 1896) | typedef Templates23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates24 (line 1911) | typedef Templates24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates25 (line 1926) | typedef Templates25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates26 (line 1941) | typedef Templates26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates27 (line 1957) | typedef Templates27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates28 (line 1974) | typedef Templates28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates29 (line 1991) | typedef Templates29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates30 (line 2009) | typedef Templates30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates31 (line 2027) | typedef Templates31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates32 (line 2045) | typedef Templates32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates33 (line 2064) | typedef Templates33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates34 (line 2083) | typedef Templates34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates35 (line 2102) | typedef Templates35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates36 (line 2122) | typedef Templates36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates37 (line 2142) | typedef Templates37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates38 (line 2162) | typedef Templates38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates39 (line 2183) | typedef Templates39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates40 (line 2204) | typedef Templates40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates41 (line 2225) | typedef Templates41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates42 (line 2248) | typedef Templates42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates43 (line 2271) | typedef Templates43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates44 (line 2294) | typedef Templates44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates45 (line 2318) | typedef Templates45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates46 (line 2342) | typedef Templates46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates47 (line 2366) | typedef Templates47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates48 (line 2391) | typedef Templates48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates49 (line 2416) | typedef Templates49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
type Templates (line 2469) | struct Templates
type Types1 (line 3303) | typedef Types1<T> type;
FILE: src/competitiveProgramming/headers/FileBuilderSample.hpp
function main (line 5) | int main(int argc, char **argv) {
FILE: src/competitiveProgramming/headers/competitive/programming/gametheory/Common.hpp
type competitive (line 15) | namespace competitive {
type programming (line 16) | namespace programming {
type gametheory (line 17) | namespace gametheory {
class IGame (line 21) | class IGame {
class IMove (line 49) | class IMove {
class ICancellableMove (line 72) | class ICancellableMove {
class IMoveGenerator (line 104) | class IMoveGenerator {
FILE: src/competitiveProgramming/headers/competitive/programming/gametheory/TreeNode.hpp
type competitive (line 13) | namespace competitive {
type programming (line 14) | namespace programming {
type gametheory (line 15) | namespace gametheory {
class TreeNode (line 24) | class TreeNode {
method TreeNode (line 26) | TreeNode(const M& move, int currentPlayer, const std::vector<dou...
method TreeNode (line 29) | TreeNode(const TreeNode<M>& other) :
method IScoreConverter (line 56) | IScoreConverter& getConverter() const {
method getDepth (line 60) | int getDepth() const {
method decrementDepth (line 64) | void decrementDepth() {
method M (line 72) | const M& getMove() const {
FILE: src/competitiveProgramming/headers/competitive/programming/gametheory/maxntree/MaxNTree.hpp
type competitive (line 35) | namespace competitive {
type programming (line 36) | namespace programming {
type gametheory (line 37) | namespace gametheory {
type maxntree (line 38) | namespace maxntree {
class MaxNTree (line 41) | class MaxNTree {
method MaxNTree (line 53) | MaxNTree(timemanagement::Timer& timer, IScoreConverter& conver...
method M (line 74) | M best(G& game, IMoveGenerator<M, G>& generator, int depthStar...
method evaluations (line 94) | int evaluations() {
method bestInternal (line 98) | TreeNode<M> bestInternal(int depth, G& board, IMoveGenerator<M...
method evaluatesMoves (line 110) | std::set<TreeNode<M> > evaluatesMoves(std::vector<M>& generate...
FILE: src/competitiveProgramming/headers/competitive/programming/gametheory/minimax/Minimax.hpp
type competitive (line 29) | namespace competitive {
type programming (line 30) | namespace programming {
type gametheory (line 31) | namespace gametheory {
type minimax (line 32) | namespace minimax {
class AlphaBetaPrunningException (line 34) | class AlphaBetaPrunningException: public std::exception {
class MinMaxEvaluatedMove (line 38) | class MinMaxEvaluatedMove {
method M (line 51) | const M& getMove() const {
method getBestSubMove (line 55) | std::shared_ptr<MinMaxEvaluatedMove<M> > getBestSubMove() const {
method getValue (line 59) | double getValue() const {
class Minimax (line 69) | class Minimax {
method Minimax (line 78) | Minimax(const timemanagement::Timer& timer): m_depthmax(0), m_...
method M (line 98) | M best(G& game, IMoveGenerator<M, G>& generator, int depthStar...
method evaluateSubPossibilities (line 120) | std::set<MinMaxEvaluatedMove<M> > evaluateSubPossibilities(
method minimax (line 178) | std::shared_ptr<MinMaxEvaluatedMove<M> > minimax (
method finalStateEvaluation (line 196) | std::shared_ptr<MinMaxEvaluatedMove<M> > finalStateEvaluation(...
method scoreFromEvaluatedGame (line 199) | double scoreFromEvaluatedGame(const std::vector<double>& score...
FILE: src/competitiveProgramming/headers/competitive/programming/gametheory/treeSearch/TreeSearch.hpp
type competitive (line 45) | namespace competitive {
type programming (line 46) | namespace programming {
type gametheory (line 47) | namespace gametheory {
type treeSearch (line 48) | namespace treeSearch {
class TreeSearchNode (line 50) | class TreeSearchNode {
method TreeSearchNode (line 52) | TreeSearchNode(const std::vector<double>& evaluation, const M&...
method TreeSearchNode (line 62) | TreeSearchNode(const TreeSearchNode<M,G>& other) :
method isBetter (line 82) | bool isBetter(const TreeSearchNode<M, G>& other) const {
method backPropagate (line 87) | void backPropagate(const std::vector<double>& subNodeValue, bo...
method decrementDepth (line 96) | void decrementDepth() {
method getGame (line 105) | std::shared_ptr<G> getGame() const {
method resetEvaluation (line 120) | void resetEvaluation() {
method isBetter (line 135) | bool isBetter(const std::vector<double>& nodeValue1, int playe...
class TreeSearchNodeSetItem (line 150) | class TreeSearchNodeSetItem {
method TreeSearchNodeSetItem (line 152) | TreeSearchNodeSetItem(TreeSearchNode<M, G>& node): m_node(node) {
class TreeSearch (line 165) | class TreeSearch {
method TreeSearch (line 185) | TreeSearch(timemanagement::Timer& timer, double depthPenaltyFa...
method M (line 206) | M best(const std::shared_ptr<G>& game, IMoveGenerator<M, G>& g...
method print (line 241) | void print(std::iostream& out) {
method bestGame (line 251) | std::shared_ptr<G> bestGame() const {
method setEvaluationsMax (line 261) | void setEvaluationsMax(int evaluationsMax) {
method evaluations (line 268) | int evaluations() const {
method prun (line 282) | void prun(const M& executedMove, IMoveGenerator<M, G>& generat...
method M (line 319) | M continueBest(IMoveGenerator<M, G>& generator) {
method bestEval (line 334) | std::vector<double> bestEval() const {
method expansion (line 339) | void expansion(std::vector<Node>&subNodes, typename TreeNodeSe...
method pushInToBeExpanded (line 353) | void pushInToBeExpanded(Node& node) {
method Node (line 357) | Node evaluate(std::shared_ptr<G> newNodeState, M& move, int de...
method treeSearchLoop (line 370) | void treeSearchLoop(IMoveGenerator<M, G>& generator) {
method M (line 385) | M returnCurrentBest(int currentPlayer) {
method repushToBeExpandedNodes (line 398) | void repushToBeExpandedNodes(Node& node) {
method printNode (line 410) | void printNode(const Node& node, std::iostream& out) {
method selection (line 418) | typename TreeNodeSet::const_iterator selection() const {
FILE: src/competitiveProgramming/headers/competitive/programming/genetic/GeneticAlgorithm.hpp
type competitive (line 22) | namespace competitive{
type programming (line 23) | namespace programming{
type genetic (line 24) | namespace genetic{
class GeneticAlgorithm (line 26) | class GeneticAlgorithm {
method GeneticAlgorithm (line 43) | GeneticAlgorithm(
method Genotype (line 64) | Genotype best() const{
method initialize (line 75) | void initialize(int initialPoolSize) {
method iterate (line 98) | void iterate(int numberOfIterations, int iterationAdditionalRand...
method addReference (line 111) | void addReference(const Genotype& reference) {
method getEvaluations (line 117) | int getEvaluations() const{
method computeScores (line 122) | void computeScores() {
method dropUnselected (line 140) | void dropUnselected(int selectionNumber) {
method addRandomCandidates (line 143) | void addRandomCandidates(int initialPoolSize) {
method merge (line 149) | void merge(int mergedNumber) {
method mutate (line 158) | void mutate(int mutatedNumber) {
method runOneIteration (line 164) | double runOneIteration(int iterationAdditionalRandomGenerated, i...
method sortByScore (line 175) | void sortByScore() {
method shuffle (line 183) | void shuffle() {
FILE: src/competitiveProgramming/headers/competitive/programming/geometry/Point.hpp
type competitive (line 15) | namespace competitive{
type programming (line 16) | namespace programming{
type geometry (line 17) | namespace geometry{
class Point (line 20) | class Point {
method Point (line 33) | Point(T x, T y):m_x(x), m_y(y) {
method Point (line 42) | Point(const Point<T>& other):m_x(other.m_x), m_y(other.m_y) {
method Point (line 52) | Point operator+(const Point& other) const{
method T (line 60) | T getX() const {
method T (line 67) | T getY() const {
method Point (line 87) | Point operator-(const Point& other) const{
method Point (line 108) | Point operator*(double factor) const {
method T (line 129) | T distanceSquare(const Point& coord) const {
method distance (line 140) | double distance(const Point& coord) const {
method Point (line 149) | Point negate() {
method Point (line 160) | Point rotateInDegree(double degree){
method Point (line 171) | Point rotateInRadian(double radians) const {
method angleInDegree (line 184) | double angleInDegree() const {
method angleInRadian (line 192) | double angleInRadian() const {
method T (line 204) | T dot(Point other) const {
method length (line 216) | double length() const{
method T (line 223) | T lengthSquare() const {
method Point (line 232) | Point norm() const{
method normInplace (line 242) | void normInplace() {
method Point (line 259) | Point ortho() {
method toDegrees (line 263) | static double toDegrees(double radians) {
method toRadians (line 266) | static double toRadians(double degrees) {
FILE: src/competitiveProgramming/headers/competitive/programming/graph/Graph.hpp
type competitive (line 29) | namespace competitive{
type programming (line 30) | namespace programming{
type graph (line 31) | namespace graph{
class Graph (line 33) | class Graph {
method Graph (line 58) | Graph(const std::vector<N>& nodes, const std::vector<int>& links...
method breadthFirstSearch (line 94) | std::vector<T> breadthFirstSearch(
method iterativeBreadthFirstSearch (line 113) | void iterativeBreadthFirstSearch(std::vector<T>& results, std::v...
method createLink (line 133) | void createLink(int sourceIndex, int destinationIndex) {
FILE: src/competitiveProgramming/headers/competitive/programming/math/Complex.hpp
type competitive (line 13) | namespace competitive {
type programming (line 14) | namespace programming {
type math (line 15) | namespace math {
class Complex (line 16) | class Complex {
method Complex (line 25) | Complex(double real, double imaginary): m_real(real), m_imaginar...
method getReal (line 27) | double getReal() const {
method getImaginary (line 30) | double getImaginary() const {
method isReal (line 37) | bool isReal() {
FILE: src/competitiveProgramming/headers/competitive/programming/math/QuadraticEquation.hpp
type competitive (line 15) | namespace competitive {
type programming (line 16) | namespace programming {
type math (line 17) | namespace math {
class QuadraticEquation (line 18) | class QuadraticEquation {
method QuadraticEquation (line 26) | QuadraticEquation(double a, double b, double c) :m_solutionsCoun...
method getSolutionsCount (line 67) | int getSolutionsCount()const {
method Complex (line 74) | const Complex& getFirstRoot() const {
method Complex (line 81) | const Complex& getSecondRoot() const {
FILE: src/competitiveProgramming/headers/competitive/programming/physics/Disk.hpp
type competitive (line 18) | namespace competitive{
type programming (line 19) | namespace programming{
type physics (line 20) | namespace physics{
class Disk (line 21) | class Disk {
method Disk (line 35) | Disk(const Vector& position, const Vector& speed, double radius)...
method Disk (line 48) | Disk(double positionX, double positionY, double speedX, double s...
method Vector (line 51) | const Vector& getPosition()const {
method Vector (line 55) | const Vector& getSpeed() const {
method getRadius (line 59) | double getRadius() const {
method Disk (line 73) | Disk move() const {
method moveInPlace (line 80) | void moveInPlace() {
method Disk (line 91) | Disk accelerate(const Vector& acceleration) const {
method accelerateInPlace (line 101) | void accelerateInPlace(const Vector& acceleration) {
method Disk (line 112) | Disk accelerate(double factor) const {
method accelerateInPlace (line 121) | void accelerateInPlace(double factor) {
method willCollide (line 134) | bool willCollide(const Disk& other) const {
method collisionTime (line 159) | double collisionTime(Disk other) const{
FILE: src/competitiveProgramming/headers/competitive/programming/timemanagement/Timer.hpp
type competitive (line 15) | namespace competitive {
type programming (line 16) | namespace programming {
type timemanagement (line 17) | namespace timemanagement {
type TimeoutException (line 19) | struct TimeoutException : public std::exception
method TimeoutException (line 21) | TimeoutException(): std::exception()
class Timer (line 25) | class Timer
method Timer (line 28) | Timer() : m_startTime(), m_timeOut(), m_started(false)
method startTimer (line 40) | void startTimer(double durationInMilliseconds)
method timeCheck (line 52) | void timeCheck() const {
method currentTimeTakenInNanoSeconds (line 66) | std::chrono::nanoseconds currentTimeTakenInNanoSeconds() const {
FILE: src/competitiveProgrammingTest/cpp/competitive/programming/gametheory/TreesTest.cpp
class StickGame (line 25) | class StickGame: public IGame {
method StickGame (line 27) | StickGame(int currentPlayer, int sticksRemaining, bool gameStateDuplic...
method changePlayer (line 32) | void changePlayer() {
method currentPlayer (line 36) | virtual int currentPlayer() const override {
method evaluate (line 40) | std::vector<double> evaluate(int depth) const override{
method getSticksRemaining (line 59) | int getSticksRemaining() const {
method setSticksRemaining (line 63) | void setSticksRemaining(int sticksRemaining) {
method isGameStateDuplication (line 67) | bool isGameStateDuplication() const {
method assignEvaluation (line 71) | void assignEvaluation(std::vector<double>& evaluation, double eval) co...
class StickMove (line 88) | class StickMove : public ICancellableMove<StickGame> {
method StickMove (line 90) | StickMove(int sticks): m_sticks(sticks), m_previousGame(), m_nextGame()
method StickMove (line 94) | StickMove(): m_sticks(0), m_previousGame(), m_nextGame()
method StickMove (line 96) | StickMove(const StickMove& other): m_sticks(other.m_sticks), m_previou...
method StickMove (line 98) | StickMove& operator=(const StickMove& other) {
method StickGame (line 108) | StickGame& cancel(StickGame& game) {
method StickGame (line 117) | StickGame& execute(StickGame& game) {
method execute (line 129) | std::shared_ptr<StickGame> execute(std::shared_ptr<StickGame>& game) {
method getSticks (line 135) | int getSticks() const {
method setSticks (line 139) | void setSticks(int sticks) {
class StickGenerator (line 148) | class StickGenerator : public IMoveGenerator<StickMove, StickGame> {
method generateMoves (line 150) | std::vector<StickMove> generateMoves(const StickGame& game) const over...
class Tester (line 167) | class Tester {
method testAlgo (line 169) | static void testAlgo(const std::function<StickMove (StickGame&, StickG...
function TEST (line 201) | TEST(MaxNTree, StickGame) {
function TEST (line 210) | TEST(Minimax, StickGame) {
function TEST (line 218) | TEST(TreeSearch, StickGame) {
FILE: src/competitiveProgrammingTest/cpp/competitive/programming/genetic/GeneticAlgorithmTest.cpp
class Combination (line 14) | class Combination {
method Combination (line 16) | Combination(int first, int second, int third, int fourth): m_first(fir...
method Combination (line 36) | static Combination newInstance() {
method evaluate (line 41) | double evaluate(const Combination& toBeFound) const {
method Combination (line 59) | Combination merge(const Combination& other) const {
method Combination (line 67) | Combination mutate() const {
method randomBoolean (line 76) | bool randomBoolean() const {
function TEST (line 90) | TEST(GeneticAlgorithm, Combination) {
FILE: src/competitiveProgrammingTest/cpp/competitive/programming/geometry/PointTest.cpp
function TEST (line 11) | TEST(Coord, Add)
function TEST (line 23) | TEST(Coord, Distances)
function TEST (line 32) | TEST(Coord, Minus)
function TEST (line 42) | TEST(Coord, Multiply)
function TEST (line 53) | TEST(Vector, BasicOperations) {
FILE: src/competitiveProgrammingTest/cpp/competitive/programming/graph/GraphTest.cpp
function TEST (line 10) | TEST(Graph, UndirectedGraph)
function TEST (line 35) | TEST(Graph, DirectedGraph) {
function TEST (line 54) | TEST(Graph, PerformancesBFS) {
FILE: src/competitiveProgrammingTest/cpp/competitive/programming/math/QuadraticEquationTest.cpp
function TEST (line 9) | TEST(QuadraticEquation, RealSolutions)
function TEST (line 30) | TEST(QuadraticEquation, ImaginarySolutions)
FILE: src/competitiveProgrammingTest/cpp/competitive/programming/physics/DiskTest.cpp
function TEST (line 9) | TEST(Disk, Move)
function TEST (line 18) | TEST(Disk, Accelerate)
function TEST (line 30) | TEST(Disk, CollisionDetection)
function TEST (line 48) | TEST(Disk, CollisionTime)
FILE: src/competitiveProgrammingTest/cpp/competitive/programming/timemanagement/TimerTest.cpp
function sleep (line 10) | static void sleep(std::chrono::milliseconds sleep) {
function TEST (line 14) | TEST(Timer, NonStartedTimerDoesNotTimeOut)
function TEST (line 28) | TEST(Timer, DoesNotTimeoutBeforeTimeoutReached) {
function TEST (line 39) | TEST(Timer, timeOutReached) {
FILE: src/competitiveProgrammingTest/cpp/test_main.cpp
function main (line 5) | int main(int argc, char **argv) {
FILE: src/main/java/builder/FileBuilder.java
class FileBuilder (line 31) | public class FileBuilder {
class ClassCode (line 47) | private static class ClassCode {
method ClassCode (line 56) | ClassCode(String classFile) {
method className (line 60) | public String className() {
method declaration (line 64) | public String declaration() {
method declaration (line 68) | public void declaration(String line, String keyword) {
method equals (line 73) | @Override
method extractDeclaration (line 95) | private String extractDeclaration(String line, String str) {
method hashCode (line 99) | @Override
method main (line 108) | public static void main(String[] args) {
method FileBuilder (line 119) | private FileBuilder(boolean javaCode) {
method addLineToCode (line 128) | private boolean addLineToCode(final ClassCode code, boolean fileKeyWor...
method includeToPath (line 179) | private String includeToPath(String includeStr) {
method importToPath (line 184) | private String importToPath(String importStr) {
method processFile (line 190) | private ClassCode processFile(String fileName) {
method readFile (line 202) | private List<String> readFile(String fileName) {
method readFileContent (line 211) | private ClassCode readFileContent(String fileName, List<String> fileCo...
method readPackageClasses (line 245) | private void readPackageClasses(String fileName) {
method toAbsolutePath (line 261) | private String toAbsolutePath(Path path) {
method toAbsolutePath (line 265) | private String toAbsolutePath(String fileName) {
method write (line 269) | private void write(ClassCode treated) {
FILE: src/main/java/builder/sample/Sample.java
class Sample (line 8) | public class Sample {
method main (line 9) | public static void main(String[] args) {
FILE: src/main/java/competitive/programming/common/Constants.java
class Constants (line 10) | public class Constants {
FILE: src/main/java/competitive/programming/containers/Pair.java
class Pair (line 14) | public class Pair<F, S> {
method Pair (line 18) | public Pair(F first, S second) {
method getSecond (line 23) | public S getSecond() {
method getFirst (line 27) | public F getFirst() {
FILE: src/main/java/competitive/programming/gametheory/ICancellableMove.java
type ICancellableMove (line 16) | public interface ICancellableMove<G extends IGame> extends IMove<G> {
method cancel (line 25) | G cancel(G game);
FILE: src/main/java/competitive/programming/gametheory/IGame.java
type IGame (line 8) | public interface IGame {
method currentPlayer (line 15) | int currentPlayer();
method evaluate (line 25) | double[] evaluate(int depth);
FILE: src/main/java/competitive/programming/gametheory/IMove.java
type IMove (line 12) | public interface IMove<G extends IGame> {
method execute (line 21) | G execute(G game);
FILE: src/main/java/competitive/programming/gametheory/IMoveGenerator.java
type IMoveGenerator (line 17) | public interface IMoveGenerator<M extends IMove<G>, G extends IGame> {
method generateMoves (line 29) | List<M> generateMoves(G game);
FILE: src/main/java/competitive/programming/gametheory/common/IScoreConverter.java
type IScoreConverter (line 10) | @FunctionalInterface
method convert (line 12) | double convert(double[] rawScores, int player);
FILE: src/main/java/competitive/programming/gametheory/common/TreeNode.java
class TreeNode (line 5) | public class TreeNode<M, G> {
method TreeNode (line 11) | public TreeNode(double[] evaluation, M move, G game, int depth) {
method decrementDepth (line 18) | public void decrementDepth() {
method getDepth (line 22) | public int getDepth() {
method getEvaluation (line 26) | public double[] getEvaluation() {
method getMove (line 30) | public M getMove() {
method getGame (line 34) | public G getGame() {
method toString (line 38) | @Override
FILE: src/main/java/competitive/programming/gametheory/common/TreeNodeSorter.java
class TreeNodeSorter (line 6) | public class TreeNodeSorter<M, G> {
method TreeNodeSorter (line 9) | public TreeNodeSorter(IScoreConverter converter) {
method best (line 13) | public TreeNode<M, G> best(List<? extends TreeNode<M, G>> moves, int p...
method compare (line 18) | private static int compare(double[] scores1, double evaluation1Factor,...
method compare (line 30) | public int compare(double[] evaluation1, double evaluation1Factor, int...
method isBetter (line 34) | public boolean isBetter(double[] evaluation1, double evaluation1Factor...
FILE: src/main/java/competitive/programming/gametheory/maxntree/MaxNTree.java
class MaxNTree (line 40) | public class MaxNTree<M extends ICancellableMove<G>, G extends IGame> {
method MaxNTree (line 62) | public MaxNTree(Timer timer, IScoreConverter converter) {
method best (line 83) | public M best(G game, IMoveGenerator<M, G> generator, int depthStart, ...
method bestGame (line 102) | public G bestGame() {
method bestInternal (line 106) | private TreeNode<M, G> bestInternal(int depth, G board) throws Timeout...
method evaluatesMoves (line 121) | private List<TreeNode<M, G>> evaluatesMoves(List<M> generatedMoves, G ...
method evaluations (line 145) | public int evaluations() {
FILE: src/main/java/competitive/programming/gametheory/minimax/Minimax.java
class Minimax (line 30) | public class Minimax<M extends ICancellableMove<G>, G extends IGame> {
class AlphaBetaPrunningException (line 32) | private static class AlphaBetaPrunningException extends Exception {
class MinMaxEvaluatedMove (line 36) | private class MinMaxEvaluatedMove implements Comparable<MinMaxEvaluate...
method MinMaxEvaluatedMove (line 41) | public MinMaxEvaluatedMove(M move, double value, MinMaxEvaluatedMove...
method compareTo (line 47) | @Override
method getBestSubMove (line 57) | public MinMaxEvaluatedMove getBestSubMove() {
method getMove (line 61) | public M getMove() {
method getValue (line 65) | public double getValue() {
method toString (line 69) | @Override
method Minimax (line 98) | public Minimax(Timer timer) {
method evaluateSubPossibilities (line 102) | private List<MinMaxEvaluatedMove> evaluateSubPossibilities(G game, IMo...
method minimax (line 154) | private MinMaxEvaluatedMove minimax(G game, IMoveGenerator<M, G> gener...
method best (line 189) | public M best(final G game, final IMoveGenerator<M, G> generator, int ...
method scoreFromEvaluatedGame (line 211) | private double scoreFromEvaluatedGame(double[] scores) {
FILE: src/main/java/competitive/programming/gametheory/treesearch/TreeSearch.java
class TreeSearch (line 48) | public class TreeSearch<M extends IMove<G>, G extends IGame> {
class TreeSearchNode (line 58) | static class TreeSearchNode<M, G extends IGame> extends TreeNode<M, G> {
method TreeSearchNode (line 65) | public TreeSearchNode(double[] evaluation, M move, G game, int depth...
method toString (line 73) | @Override
method backPropagate (line 78) | public void backPropagate(double[] subNodeValue, TreeNodeSorter<M, G...
method decrementDepth (line 87) | @Override
method setSubNodes (line 93) | public void setSubNodes(List<TreeSearchNode<M, G>> subNodes) {
method resetEvaluation (line 97) | public void resetEvaluation(TreeNodeSorter<M, G> sorter) {
method TreeSearch (line 128) | public TreeSearch(Timer timer, double depthPenaltyFactor, IScoreConver...
method best (line 144) | public M best(final G game, final IMoveGenerator<M, G> generator) {
method getToBeExpanded (line 164) | protected Queue<TreeSearchNode<M, G>> getToBeExpanded() {
method print (line 175) | public void print(PrintStream out) {
method bestGame (line 187) | public G bestGame() {
method setEvaluationsMax (line 199) | public void setEvaluationsMax(int evaluationsMax) {
method evaluations (line 206) | public int evaluations() {
method prun (line 220) | public void prun(M executedMove, IMoveGenerator<M, G> generator) {
method continueBest (line 253) | public M continueBest(IMoveGenerator<M, G> generator) {
method bestEval (line 267) | public double[] bestEval() {
method createToBeExpanded (line 271) | private PriorityQueue<TreeSearchNode<M, G>> createToBeExpanded() {
method expansion (line 275) | private List<TreeSearchNode<M, G>> expansion(TreeSearchNode<M, G> toEx...
method pushInToBeExpanded (line 289) | private void pushInToBeExpanded(TreeSearchNode<M, G> node) {
method evaluate (line 293) | private TreeSearchNode<M, G> evaluate(G newNodeState, M move, int dept...
method treeSearchLoop (line 306) | private void treeSearchLoop(final IMoveGenerator<M, G> generator) thro...
method returnCurrentBest (line 319) | private M returnCurrentBest(int currentPlayer) {
method repushToBeExpandedNodes (line 332) | private void repushToBeExpandedNodes(TreeSearchNode<M, G> node) {
method printNode (line 344) | private void printNode(TreeSearchNode<M, G> node, PrintStream out) {
FILE: src/main/java/competitive/programming/genetic/CandidateGenerator.java
type CandidateGenerator (line 11) | public interface CandidateGenerator<Genotype> {
method generateRandomly (line 16) | Genotype generateRandomly();
FILE: src/main/java/competitive/programming/genetic/CandidateMerger.java
type CandidateMerger (line 11) | public interface CandidateMerger<Genotype> {
method merge (line 20) | Genotype merge(Genotype first, Genotype second);
FILE: src/main/java/competitive/programming/genetic/CandidateMutator.java
type CandidateMutator (line 11) | public interface CandidateMutator<Genotype> {
method mutate (line 18) | Genotype mutate(Genotype candidate);
FILE: src/main/java/competitive/programming/genetic/FitnessFunction.java
type FitnessFunction (line 11) | public interface FitnessFunction<Genotype> {
method evaluate (line 18) | double evaluate(Genotype genotype);
FILE: src/main/java/competitive/programming/genetic/GeneticAlgorithm.java
class GeneticAlgorithm (line 23) | public class GeneticAlgorithm<Genotype> {
type IShuffler (line 25) | protected interface IShuffler<Genotype> {
method shuffle (line 26) | void shuffle(List<? extends Genotype> list);
method GeneticAlgorithm (line 52) | public GeneticAlgorithm(FitnessFunction<Genotype> fitnessFunction, Can...
method addRandomCandidates (line 60) | private void addRandomCandidates(int initialPoolSize) {
method best (line 71) | public Genotype best() {
method computeScores (line 75) | private Map<Genotype, Double> computeScores() {
method dropUnselected (line 92) | private void dropUnselected(int selectionNumber) {
method initialize (line 104) | public void initialize(int initialPoolSize) {
method iterate (line 127) | public void iterate(int numberOfIterations, int iterationAdditionalRan...
method merge (line 133) | private void merge(int mergedNumber) {
method mutate (line 141) | private void mutate(int mutatedNumber) {
method printTo (line 148) | protected void printTo(PrintStream err) {
method removeDuplicates (line 153) | private void removeDuplicates() {
method runOneIteration (line 159) | private double runOneIteration(int iterationAdditionalRandomGenerated,...
method setShuffler (line 172) | protected void setShuffler(IShuffler<Genotype> shuffler) {
method shuffle (line 176) | private void shuffle() {
method sortByScore (line 180) | private void sortByScore(final Map<Genotype, Double> scores) {
method addReference (line 202) | public void addReference(Genotype reference) {
method getEvaluations (line 206) | public int getEvaluations() {
FILE: src/main/java/competitive/programming/geometry/Coord.java
class Coord (line 11) | public class Coord {
method Coord (line 23) | public Coord(int x, int y) {
method Coord (line 35) | public Coord(Vector v) {
method add (line 48) | public Coord add(Coord coord) {
method distance (line 57) | public double distance(Coord coord) {
method distanceSquare (line 69) | public long distanceSquare(Coord coord) {
method minus (line 83) | public Coord minus(Coord coord) {
method equals (line 87) | @Override
method hashCode (line 108) | @Override
method toString (line 117) | @Override
FILE: src/main/java/competitive/programming/geometry/Vector.java
class Vector (line 10) | public class Vector {
method doubleToString (line 11) | private static String doubleToString(double d) {
method Vector (line 29) | public Vector(Coord coord) {
method Vector (line 40) | public Vector(double x, double y) {
method Vector (line 51) | public Vector(Vector other) {
method add (line 62) | public Vector add(Vector other) {
method negate (line 71) | public Vector negate() {
method rotateInDegree (line 82) | public Vector rotateInDegree(double degree){
method rotateInRadian (line 93) | public Vector rotateInRadian(double radians) {
method angleInDegree (line 105) | public double angleInDegree() {
method angleInRadian (line 113) | private double angleInRadian() {
method dot (line 125) | public double dot(Vector other) {
method equals (line 129) | @Override
method hashCode (line 150) | @Override
method length (line 166) | public double length() {
method length2 (line 173) | public double length2() {
method minus (line 185) | public Vector minus(Vector other) {
method multiply (line 196) | public Vector multiply(double factor) {
method norm (line 205) | public Vector norm() {
method ortho (line 217) | public Vector ortho() {
method toString (line 221) | @Override
FILE: src/main/java/competitive/programming/graph/Graph.java
class Graph (line 28) | public class Graph<N> {
method Graph (line 54) | public Graph(final N[] nodes, int[] linksSource, int[] linksDestinatio...
method createLink (line 74) | private void createLink(int sourceIndex, int destinationIndex) {
method breadthFirstSearch (line 103) | public double[] breadthFirstSearch(double intialValue, double firstVal...
method iterativeDoubleBreadthFirstSearch (line 116) | private void iterativeDoubleBreadthFirstSearch(double[] results, boole...
method breadthFirstSearch (line 143) | public int[] breadthFirstSearch(
method iterativeIntegerBreadthFirstSearch (line 160) | private void iterativeIntegerBreadthFirstSearch(int[] results, boolean...
FILE: src/main/java/competitive/programming/graph/IBFSTraversable.java
type IBFSTraversable (line 3) | public interface IBFSTraversable<N>{
method canBeVisited (line 4) | boolean canBeVisited(N node);
FILE: src/main/java/competitive/programming/graph/IDoubleBfsNextLevelValueIterator.java
type IDoubleBfsNextLevelValueIterator (line 3) | public interface IDoubleBfsNextLevelValueIterator<N>{
method nextInterationValue (line 4) | double nextInterationValue(double value, int iteration);
FILE: src/main/java/competitive/programming/graph/IIntegerBfsNextValueIterator.java
type IIntegerBfsNextValueIterator (line 3) | public interface IIntegerBfsNextValueIterator<N>{
method nextInterationValue (line 4) | int nextInterationValue(int value, int iteration);
FILE: src/main/java/competitive/programming/math/Complex.java
class Complex (line 9) | public class Complex {
method Complex (line 19) | public Complex(double real, double imaginary) {
method getReal (line 23) | public double getReal() {
method getImaginary (line 26) | public double getImaginary() {
method isReal (line 33) | public boolean isReal(){
method toString (line 36) | @Override
method hashCode (line 40) | @Override
method equals (line 51) | @Override
FILE: src/main/java/competitive/programming/math/QuadraticEquation.java
class QuadraticEquation (line 12) | public class QuadraticEquation {
method solve (line 22) | public static List<Complex> solve(double a, double b, double c){
FILE: src/main/java/competitive/programming/physics/Disk.java
class Disk (line 16) | public class Disk {
method Disk (line 31) | public Disk(Vector position, Vector speed, double radius) {
method hashCode (line 37) | @Override
method equals (line 49) | @Override
method move (line 79) | public Disk move() {
method accelerate (line 90) | public Disk accelerate(Vector acceleration) {
method accelerate (line 101) | public Disk accelerate(double factor) {
method willCollide (line 114) | public boolean willCollide(Disk other) {
method collisionTime (line 135) | public double collisionTime(Disk other) {
FILE: src/main/java/competitive/programming/timemanagement/TimeoutException.java
class TimeoutException (line 8) | public class TimeoutException extends Exception {
FILE: src/main/java/competitive/programming/timemanagement/Timer.java
class Timer (line 10) | public class Timer {
method currentTimeTakenInNanoSeconds (line 19) | public long currentTimeTakenInNanoSeconds() {
method startTimer (line 31) | public void startTimer(double durationInMilliseconds) {
method timeCheck (line 41) | public void timeCheck() throws TimeoutException {
FILE: src/test/java/competitive/programming/gametheory/StickGame.java
class StickGame (line 3) | public class StickGame implements IGame {
method StickGame (line 8) | public StickGame(int currentPlayer, int sticksRemaining, boolean gameS...
method assignEvaluation (line 14) | private void assignEvaluation(double[] evaluation, double eval) {
method changePlayer (line 24) | public void changePlayer() {
method currentPlayer (line 28) | @Override
method evaluate (line 33) | @Override
method getSticksRemaining (line 52) | public int getSticksRemaining() {
method setSticksRemaining (line 56) | public void setSticksRemaining(int sticksRemaining) {
method isGameStateDuplication (line 60) | public boolean isGameStateDuplication() {
FILE: src/test/java/competitive/programming/gametheory/StickGenerator.java
class StickGenerator (line 8) | public class StickGenerator implements IMoveGenerator<StickMove, StickGa...
method generateMoves (line 10) | @Override
FILE: src/test/java/competitive/programming/gametheory/StickMove.java
class StickMove (line 4) | public class StickMove implements ICancellableMove<StickGame> {
method StickMove (line 9) | public StickMove(int sticks) {
method cancel (line 13) | @Override
method execute (line 24) | @Override
method getSticks (line 37) | public int getSticks() {
method log (line 41) | private void log(StickGame game, String action) {
method setSticks (line 45) | public void setSticks(int sticks) {
method toString (line 49) | @Override
FILE: src/test/java/competitive/programming/gametheory/Tester.java
class Tester (line 8) | public class Tester {
type IBestMoveEvaluator (line 10) | public interface IBestMoveEvaluator {
method findBestMove (line 11) | StickMove findBestMove(StickGame game, StickGenerator generator, int...
method testAlgo (line 14) | public static void testAlgo(IBestMoveEvaluator evaluator, boolean game...
FILE: src/test/java/competitive/programming/gametheory/maxntree/MaxNTreeTest.java
class MaxNTreeTest (line 10) | public class MaxNTreeTest {
method testStickGame (line 12) | @Test
FILE: src/test/java/competitive/programming/gametheory/minimax/MinimaxTest.java
class MinimaxTest (line 10) | public class MinimaxTest {
method testStickGame (line 11) | @Test
FILE: src/test/java/competitive/programming/gametheory/treesearch/TreeSearchTest.java
class TreeSearchTest (line 21) | public class TreeSearchTest {
method testStickGame (line 23) | @Test
class NegValueGame (line 32) | static class NegValueGame implements IGame{
method NegValueGame (line 36) | public NegValueGame(int score, int depth) {
method currentPlayer (line 41) | @Override
method evaluate (line 46) | @Override
class NegValueMove (line 55) | static class NegValueMove implements IMove<NegValueGame>{
method execute (line 57) | @Override
method toString (line 61) | @Override
method reset (line 65) | static void reset(){
method testExpansionResetValue (line 70) | @Test
method testPrunning (line 90) | @Test
FILE: src/test/java/competitive/programming/genetic/GeneticAlgorithmTest.java
class GeneticAlgorithmTest (line 12) | public class GeneticAlgorithmTest {
class Combination (line 14) | private static class Combination {
method newInstance (line 15) | public static Combination newInstance() {
method Combination (line 26) | public Combination(int first, int second, int third, int fourth) {
method equals (line 33) | @Override
method evaluate (line 60) | public double evaluate(Combination toBeFound) {
method hashCode (line 79) | @Override
method merge (line 90) | public Combination merge(Combination other) {
method mutate (line 95) | public Combination mutate() {
method randomBoolean (line 99) | private boolean randomBoolean() {
method toString (line 103) | @Override
method testCombinationGuesser (line 113) | @Test
FILE: src/test/java/competitive/programming/geometry/CoordTest.java
class CoordTest (line 7) | public class CoordTest {
method add (line 9) | @Test
method distances (line 16) | @Test
method minus (line 25) | @Test
method convertFromVector (line 32) | @Test
FILE: src/test/java/competitive/programming/geometry/VectorTest.java
class VectorTest (line 9) | public class VectorTest {
method vectorBasicOperations (line 11) | @Test
FILE: src/test/java/competitive/programming/graph/GraphTest.java
class GraphTest (line 14) | public class GraphTest {
method init (line 19) | @Before
method bfsOnGraph (line 46) | @Test
method performancesBFS (line 66) | @Test
FILE: src/test/java/competitive/programming/math/QuadraticEquationTest.java
class QuadraticEquationTest (line 12) | public class QuadraticEquationTest {
method testRealSolutions (line 14) | @Test
method imaginarySolutions (line 23) | @Test
FILE: src/test/java/competitive/programming/physics/DiskTest.java
class DiskTest (line 10) | public class DiskTest {
method testMove (line 13) | @Test
method testAccelerate (line 19) | @Test
method testCollisionDetection (line 26) | @Test
method collisionTime (line 43) | @Test
FILE: src/test/java/competitive/programming/timemanagement/TimerTest.java
class TimerTest (line 7) | public class TimerTest {
method nonStartedTimerDoesNotTimeout (line 9) | @Test
method doesNotTimeOutBeforeTimeoutReached (line 21) | @Test
method timeoutReached (line 36) | @Test(expected = TimeoutException.class)
method sleep (line 44) | private void sleep(long milliseconds) {
Condensed preview — 105 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (1,151K chars).
[
{
"path": ".classpath",
"chars": 745,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<classpath>\r\n\t<classpathentry kind=\"src\" path=\"src/main/java\"/>\r\n\t<classpathentr"
},
{
"path": ".gitignore",
"chars": 90,
"preview": "/bin/\n/target/\n/.settings/\n/vs/\n/build/\n/.gradle/\n.idea\n*.vcxproj\n*.vcxproj.filters\n*.iml\n"
},
{
"path": ".project",
"chars": 706,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<projectDescription>\r\n\t<name>competitive-programming</name>\r\n\t<comment></comment"
},
{
"path": ".travis.yml",
"chars": 603,
"preview": "language: java\njdk: \n - oraclejdk8\nbefore_install:\n - sudo sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test\n - "
},
{
"path": "LICENSE",
"chars": 11357,
"preview": " Apache License\n Version 2.0, January 2004\n "
},
{
"path": "README.md",
"chars": 4977,
"preview": "[](https://travis-ci.org/Manwe56"
},
{
"path": "build.gradle",
"chars": 3199,
"preview": "apply plugin: 'java'\napply plugin: 'cpp'\napply plugin: 'maven'\napply plugin: 'eclipse'\napply plugin: 'google-test-test-s"
},
{
"path": "libs/googleTest/1.7.0/include/gtest/gtest-death-test.h",
"chars": 11523,
"preview": "// Copyright 2005, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "libs/googleTest/1.7.0/include/gtest/gtest-message.h",
"chars": 9186,
"preview": "// Copyright 2005, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "libs/googleTest/1.7.0/include/gtest/gtest-param-test.h",
"chars": 75864,
"preview": "// This file was GENERATED by command:\n// pump.py gtest-param-test.h.pump\n// DO NOT EDIT BY HAND!!!\n\n// Copyright 20"
},
{
"path": "libs/googleTest/1.7.0/include/gtest/gtest-param-test.h.pump",
"chars": 18796,
"preview": "$$ -*- mode: c++; -*-\n$var n = 50 $$ Maximum length of Values arguments we want to support.\n$var maxtuple = 10 $$ Maxi"
},
{
"path": "libs/googleTest/1.7.0/include/gtest/gtest-printers.h",
"chars": 31609,
"preview": "// Copyright 2007, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "libs/googleTest/1.7.0/include/gtest/gtest-spi.h",
"chars": 9952,
"preview": "// Copyright 2007, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "libs/googleTest/1.7.0/include/gtest/gtest-test-part.h",
"chars": 6509,
"preview": "// Copyright 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "libs/googleTest/1.7.0/include/gtest/gtest-typed-test.h",
"chars": 10242,
"preview": "// Copyright 2008 Google Inc.\n// All Rights Reserved.\n//\n// Redistribution and use in source and binary forms, with or w"
},
{
"path": "libs/googleTest/1.7.0/include/gtest/gtest.h",
"chars": 88434,
"preview": "// Copyright 2005, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "libs/googleTest/1.7.0/include/gtest/gtest_pred_impl.h",
"chars": 15145,
"preview": "// Copyright 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "libs/googleTest/1.7.0/include/gtest/gtest_prod.h",
"chars": 2324,
"preview": "// Copyright 2006, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "libs/googleTest/1.7.0/include/gtest/internal/gtest-death-test-internal.h",
"chars": 13429,
"preview": "// Copyright 2005, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "libs/googleTest/1.7.0/include/gtest/internal/gtest-filepath.h",
"chars": 9603,
"preview": "// Copyright 2008, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "libs/googleTest/1.7.0/include/gtest/internal/gtest-internal.h",
"chars": 44145,
"preview": "// Copyright 2005, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "libs/googleTest/1.7.0/include/gtest/internal/gtest-linked_ptr.h",
"chars": 8101,
"preview": "// Copyright 2003 Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or w"
},
{
"path": "libs/googleTest/1.7.0/include/gtest/internal/gtest-param-util-generated.h",
"chars": 192176,
"preview": "// This file was GENERATED by command:\n// pump.py gtest-param-util-generated.h.pump\n// DO NOT EDIT BY HAND!!!\n\n// Co"
},
{
"path": "libs/googleTest/1.7.0/include/gtest/internal/gtest-param-util-generated.h.pump",
"chars": 9416,
"preview": "$$ -*- mode: c++; -*-\n$var n = 50 $$ Maximum length of Values arguments we want to support.\n$var maxtuple = 10 $$ Maxi"
},
{
"path": "libs/googleTest/1.7.0/include/gtest/internal/gtest-param-util.h",
"chars": 24191,
"preview": "// Copyright 2008 Google Inc.\n// All Rights Reserved.\n//\n// Redistribution and use in source and binary forms, with or w"
},
{
"path": "libs/googleTest/1.7.0/include/gtest/internal/gtest-port.h",
"chars": 68796,
"preview": "// Copyright 2005, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "libs/googleTest/1.7.0/include/gtest/internal/gtest-string.h",
"chars": 6968,
"preview": "// Copyright 2005, Google Inc.\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or "
},
{
"path": "libs/googleTest/1.7.0/include/gtest/internal/gtest-tuple.h",
"chars": 28223,
"preview": "// This file was GENERATED by command:\n// pump.py gtest-tuple.h.pump\n// DO NOT EDIT BY HAND!!!\n\n// Copyright 2009 Go"
},
{
"path": "libs/googleTest/1.7.0/include/gtest/internal/gtest-tuple.h.pump",
"chars": 9226,
"preview": "$$ -*- mode: c++; -*-\n$var n = 10 $$ Maximum number of tuple fields we want to support.\n$$ This meta comment fixes auto"
},
{
"path": "libs/googleTest/1.7.0/include/gtest/internal/gtest-type-util.h",
"chars": 185666,
"preview": "// This file was GENERATED by command:\n// pump.py gtest-type-util.h.pump\n// DO NOT EDIT BY HAND!!!\n\n// Copyright 200"
},
{
"path": "libs/googleTest/1.7.0/include/gtest/internal/gtest-type-util.h.pump",
"chars": 9317,
"preview": "$$ -*- mode: c++; -*-\n$var n = 50 $$ Maximum length of type lists we want to support.\n// Copyright 2008 Google Inc.\n// "
},
{
"path": "settings.gradle",
"chars": 45,
"preview": "rootProject.name = 'competitive-programming'\n"
},
{
"path": "src/competitiveProgramming/headers/FileBuilderSample.hpp",
"chars": 294,
"preview": "#include \"competitive/programming/geometry/Point.hpp\"\r\n#include \"competitive/programming/math/QuadraticEquation.hpp\"\r\n#i"
},
{
"path": "src/competitiveProgramming/headers/competitive/programming/gametheory/Common.hpp",
"chars": 4545,
"preview": "#ifndef __GAME_THEORY_COMMON_INCLUDED__\n#define __GAME_THEORY_COMMON_INCLUDED__\n\n/**\n* @author Manwe\n*\n*\tInterfaces used"
},
{
"path": "src/competitiveProgramming/headers/competitive/programming/gametheory/TreeNode.hpp",
"chars": 1998,
"preview": "#ifndef __GAME_THEORY_TREENODE_INCLUDED__\n#define __GAME_THEORY_TREENODE_INCLUDED__\n\n/**\n* @author Manwe\n*\n* Internal cl"
},
{
"path": "src/competitiveProgramming/headers/competitive/programming/gametheory/maxntree/MaxNTree.hpp",
"chars": 4610,
"preview": "#ifndef __GAMETHEORY_MAXNTREE_INCLUDED__\n#define __GAMETHEORY_MAXNTREE_INCLUDED__\n\n\n/**\n* MaxNTree class allows "
},
{
"path": "src/competitiveProgramming/headers/competitive/programming/gametheory/minimax/Minimax.hpp",
"chars": 6839,
"preview": "#ifndef __GAMETHEORY_MINIMAX_INCLUDED__\n#define __GAMETHEORY_MINIMAX_INCLUDED__\n\n/**\n* @author Manwe\n*\n* Minimax"
},
{
"path": "src/competitiveProgramming/headers/competitive/programming/gametheory/treeSearch/TreeSearch.hpp",
"chars": 14097,
"preview": "#ifndef __GAMETHEORY_TREESEARCH_INCLUDED__\n#define __GAMETHEORY_TREESEARCH_INCLUDED__\n\n/**\n* @author Manwe\n*\n* T"
},
{
"path": "src/competitiveProgramming/headers/competitive/programming/genetic/GeneticAlgorithm.hpp",
"chars": 6506,
"preview": "#ifndef _GENETIC_GENETIC_ALGORITHM_INCLUDED\n#define _GENETIC_GENETIC_ALGORITHM_INCLUDED\n\n/**\n* @author Manwe\n*\n* Clas"
},
{
"path": "src/competitiveProgramming/headers/competitive/programming/geometry/Point.hpp",
"chars": 6028,
"preview": "#ifndef _GEOMETRY_POINT_INCLUDED\n#define _GEOMETRY_POINT_INCLUDED\n\n/**\n* @author Manwe\n*\n* Class representing a Point (x"
},
{
"path": "src/competitiveProgramming/headers/competitive/programming/graph/Graph.hpp",
"chars": 5327,
"preview": "#ifndef _GRAPH_GRAPH_INCLUDED\n#define _GRAPH_GRAPH_INCLUDED\n\n/**\n* @author Manwe\n*\n* class that models a graph a"
},
{
"path": "src/competitiveProgramming/headers/competitive/programming/math/Complex.hpp",
"chars": 1274,
"preview": "#ifndef __COMPLEX_INCLUDED__\n#define __COMPLEX_INCLUDED__\n\n/**\n* @author Manwe\n*\n* Class representing a complex number.\n"
},
{
"path": "src/competitiveProgramming/headers/competitive/programming/math/QuadraticEquation.hpp",
"chars": 2104,
"preview": "#ifndef __QUADRATIC_EQUATION_INCLUDED__\n#define __QUADRATIC_EQUATION_INCLUDED__\n\n#include \"competitive/programming/math/"
},
{
"path": "src/competitiveProgramming/headers/competitive/programming/physics/Disk.hpp",
"chars": 6045,
"preview": "#ifndef _PHYSICS_DISK_INCLUDED\n#define _PHYSICS_DISK_INCLUDED\n\n/**\n* @author Manwe\n*\n* Class representing a disk. A d"
},
{
"path": "src/competitiveProgramming/headers/competitive/programming/timemanagement/Timer.hpp",
"chars": 2473,
"preview": "#ifndef __TIMER_INCLUDED__\n#define __TIMER_INCLUDED__\n\n/**\n* @author Manwe\n*\n* Time management class in order to measure"
},
{
"path": "src/competitiveProgrammingTest/cpp/competitive/programming/gametheory/TreesTest.cpp",
"chars": 6907,
"preview": "#include \"gtest/gtest.h\"\n\n#include \"competitive/programming/gametheory/maxntree/MaxNTree.hpp\"\n#include \"competitive/prog"
},
{
"path": "src/competitiveProgrammingTest/cpp/competitive/programming/genetic/GeneticAlgorithmTest.cpp",
"chars": 2840,
"preview": "#include \"gtest/gtest.h\"\n\n#include \"competitive/programming/genetic/GeneticAlgorithm.hpp\"\n\nusing competitive::programmin"
},
{
"path": "src/competitiveProgrammingTest/cpp/competitive/programming/geometry/PointTest.cpp",
"chars": 1567,
"preview": "#include \"gtest/gtest.h\"\n\n#include \"competitive/programming/geometry/Point.hpp\"\n\n#include <math.h>\n#include <string>\n\nty"
},
{
"path": "src/competitiveProgrammingTest/cpp/competitive/programming/graph/GraphTest.cpp",
"chars": 3407,
"preview": "#include \"gtest/gtest.h\"\n\n#include \"competitive/programming/graph/Graph.hpp\"\n#include \"competitive/programming/timemanag"
},
{
"path": "src/competitiveProgrammingTest/cpp/competitive/programming/math/QuadraticEquationTest.cpp",
"chars": 1324,
"preview": "#include \"gtest/gtest.h\"\n\n#include \"competitive/programming/math/Complex.hpp\"\n#include \"competitive/programming/math/Qua"
},
{
"path": "src/competitiveProgrammingTest/cpp/competitive/programming/physics/DiskTest.cpp",
"chars": 1809,
"preview": "#include \"gtest/gtest.h\"\n\n#include \"competitive/programming/physics/Disk.hpp\"\n\n#include <cmath>\n\nusing competitive::prog"
},
{
"path": "src/competitiveProgrammingTest/cpp/competitive/programming/timemanagement/TimerTest.cpp",
"chars": 846,
"preview": "#include \"gtest/gtest.h\"\n\n#include \"competitive/programming/timemanagement/Timer.hpp\"\n\n#include <thread>\n\nusing competit"
},
{
"path": "src/competitiveProgrammingTest/cpp/test_main.cpp",
"chars": 154,
"preview": "#include \"gtest/gtest.h\"\n\nusing namespace testing;\n\nint main(int argc, char **argv) {\n testing::InitGoogleTest(&argc, a"
},
{
"path": "src/main/java/builder/FileBuilder.java",
"chars": 12256,
"preview": "package builder;\r\n\r\nimport java.io.IOException;\r\nimport java.nio.charset.Charset;\r\nimport java.nio.file.DirectoryStream;"
},
{
"path": "src/main/java/builder/sample/Sample.java",
"chars": 596,
"preview": "package builder.sample;\r\n\r\nimport java.util.Arrays;\r\nimport java.util.List;\r\n\r\nimport competitive.programming.geometry.C"
},
{
"path": "src/main/java/competitive/programming/common/Constants.java",
"chars": 269,
"preview": "package competitive.programming.common;\r\n\r\n\r\n/**\r\n * Contains constants variables common to several parts of the tools\r\n"
},
{
"path": "src/main/java/competitive/programming/containers/Pair.java",
"chars": 542,
"preview": "package competitive.programming.containers;\r\n\r\n/**\r\n * Equivalent of the std::pair in C++ Allows to easily return two va"
},
{
"path": "src/main/java/competitive/programming/gametheory/ICancellableMove.java",
"chars": 853,
"preview": "package competitive.programming.gametheory;\n\n/**\n * @author Manwe\n *\n * Interface that represent a move. This is"
},
{
"path": "src/main/java/competitive/programming/gametheory/IGame.java",
"chars": 880,
"preview": "package competitive.programming.gametheory;\r\n\r\n/**\r\n * @author Manwe\r\n *\r\n *\tInterface representing a game state\r\n */\r\np"
},
{
"path": "src/main/java/competitive/programming/gametheory/IMove.java",
"chars": 507,
"preview": "package competitive.programming.gametheory;\r\n\r\n/**\r\n * @author Manwe\r\n *\r\n * Interface that represent a move. Th"
},
{
"path": "src/main/java/competitive/programming/gametheory/IMoveGenerator.java",
"chars": 1234,
"preview": "package competitive.programming.gametheory;\r\n\r\nimport java.util.List;\r\n\r\n/**\r\n * @author Manwe\r\n *\r\n * Interface"
},
{
"path": "src/main/java/competitive/programming/gametheory/common/IScoreConverter.java",
"chars": 522,
"preview": "package competitive.programming.gametheory.common;\n\n/**\n * @author Manwe\n *\n * This interface allows to evaluate for a p"
},
{
"path": "src/main/java/competitive/programming/gametheory/common/TreeNode.java",
"chars": 909,
"preview": "package competitive.programming.gametheory.common;\r\n\r\nimport java.util.Arrays;\r\n\r\npublic class TreeNode<M, G> {\r\n pri"
},
{
"path": "src/main/java/competitive/programming/gametheory/common/TreeNodeSorter.java",
"chars": 1619,
"preview": "package competitive.programming.gametheory.common;\r\n\r\nimport java.util.Collections;\r\nimport java.util.List;\r\n\r\npublic cl"
},
{
"path": "src/main/java/competitive/programming/gametheory/maxntree/MaxNTree.java",
"chars": 5696,
"preview": "package competitive.programming.gametheory.maxntree;\r\n\r\nimport java.util.ArrayList;\r\nimport java.util.List;\r\n\r\nimport co"
},
{
"path": "src/main/java/competitive/programming/gametheory/minimax/Minimax.java",
"chars": 8807,
"preview": "package competitive.programming.gametheory.minimax;\r\n\r\nimport java.util.ArrayList;\r\nimport java.util.Collections;\r\nimpor"
},
{
"path": "src/main/java/competitive/programming/gametheory/treesearch/TreeSearch.java",
"chars": 13945,
"preview": "package competitive.programming.gametheory.treesearch;\r\n\r\nimport java.io.PrintStream;\r\nimport java.util.ArrayList;\r\nimpo"
},
{
"path": "src/main/java/competitive/programming/genetic/CandidateGenerator.java",
"chars": 420,
"preview": "package competitive.programming.genetic;\r\n\r\n/**\r\n * @author Manwe\r\n *\r\n * Interface to generate randomly a new candidate"
},
{
"path": "src/main/java/competitive/programming/genetic/CandidateMerger.java",
"chars": 607,
"preview": "package competitive.programming.genetic;\r\n\r\n/**\r\n * @author Manwe\r\n *\r\n * Interface allowing to merge two genotype in or"
},
{
"path": "src/main/java/competitive/programming/genetic/CandidateMutator.java",
"chars": 513,
"preview": "package competitive.programming.genetic;\r\n\r\n/**\r\n * @author Manwe\r\n * \r\n * Interface allowing to create a new instance o"
},
{
"path": "src/main/java/competitive/programming/genetic/FitnessFunction.java",
"chars": 548,
"preview": "package competitive.programming.genetic;\r\n\r\n/**\r\n * @author Manwe\r\n * \r\n * Interface that evaluate a candidate. During t"
},
{
"path": "src/main/java/competitive/programming/genetic/GeneticAlgorithm.java",
"chars": 7680,
"preview": "package competitive.programming.genetic;\r\n\r\nimport java.io.PrintStream;\r\nimport java.util.ArrayList;\r\nimport java.util.C"
},
{
"path": "src/main/java/competitive/programming/geometry/Coord.java",
"chars": 3071,
"preview": "package competitive.programming.geometry;\r\n\r\n/**\r\n * @author Manwe\r\n *\r\n * Class representing a position x y usi"
},
{
"path": "src/main/java/competitive/programming/geometry/Vector.java",
"chars": 5946,
"preview": "package competitive.programming.geometry;\r\n\r\n/**\r\n * @author Manwe\r\n * \r\n * Class representing a vector (x,y) with doubl"
},
{
"path": "src/main/java/competitive/programming/graph/Graph.java",
"chars": 7112,
"preview": "package competitive.programming.graph;\r\n\r\nimport java.util.ArrayList;\r\nimport java.util.Arrays;\r\nimport java.util.HashSe"
},
{
"path": "src/main/java/competitive/programming/graph/IBFSTraversable.java",
"chars": 113,
"preview": "package competitive.programming.graph;\r\n\r\npublic interface IBFSTraversable<N>{\r\n\tboolean canBeVisited(N node);\r\n}"
},
{
"path": "src/main/java/competitive/programming/graph/IDoubleBfsNextLevelValueIterator.java",
"chars": 157,
"preview": "package competitive.programming.graph;\r\n\r\npublic interface IDoubleBfsNextLevelValueIterator<N>{\r\n\tdouble nextInterationV"
},
{
"path": "src/main/java/competitive/programming/graph/IIntegerBfsNextValueIterator.java",
"chars": 147,
"preview": "package competitive.programming.graph;\r\n\r\npublic interface IIntegerBfsNextValueIterator<N>{\r\n\tint nextInterationValue(in"
},
{
"path": "src/main/java/competitive/programming/math/Complex.java",
"chars": 1689,
"preview": "package competitive.programming.math;\r\n\r\n/**\r\n * @author Manwe\r\n * \r\n * Class representing a complex number.\r\n * This co"
},
{
"path": "src/main/java/competitive/programming/math/QuadraticEquation.java",
"chars": 1283,
"preview": "package competitive.programming.math;\r\n\r\nimport java.util.ArrayList;\r\nimport java.util.List;\r\n\r\n/**\r\n * @author Manwe\r\n "
},
{
"path": "src/main/java/competitive/programming/physics/Disk.java",
"chars": 5108,
"preview": "package competitive.programming.physics;\r\n\r\nimport java.util.List;\r\n\r\nimport competitive.programming.geometry.Vector;\r\ni"
},
{
"path": "src/main/java/competitive/programming/timemanagement/TimeoutException.java",
"chars": 263,
"preview": "package competitive.programming.timemanagement;\r\n\r\n/**\r\n * @author Manwe\r\n * \r\n * Exception class thrown when a timeout "
},
{
"path": "src/main/java/competitive/programming/timemanagement/Timer.java",
"chars": 1756,
"preview": "package competitive.programming.timemanagement;\r\n\r\n\r\n/**\r\n * @author Manwe\r\n *\r\n * Time management class in order to mea"
},
{
"path": "src/test/java/competitive/programming/gametheory/StickGame.java",
"chars": 1875,
"preview": "package competitive.programming.gametheory;\r\n\r\npublic class StickGame implements IGame {\r\n private int player;\r\n p"
},
{
"path": "src/test/java/competitive/programming/gametheory/StickGenerator.java",
"chars": 718,
"preview": "package competitive.programming.gametheory;\r\n\r\nimport java.util.ArrayList;\r\nimport java.util.List;\r\n\r\nimport competitive"
},
{
"path": "src/test/java/competitive/programming/gametheory/StickMove.java",
"chars": 1489,
"preview": "package competitive.programming.gametheory;\r\n\r\n\r\npublic class StickMove implements ICancellableMove<StickGame> {\r\n\r\n "
},
{
"path": "src/test/java/competitive/programming/gametheory/Tester.java",
"chars": 1704,
"preview": "package competitive.programming.gametheory;\r\n\r\nimport static org.junit.Assert.assertEquals;\r\nimport static org.junit.Ass"
},
{
"path": "src/test/java/competitive/programming/gametheory/maxntree/MaxNTreeTest.java",
"chars": 787,
"preview": "package competitive.programming.gametheory.maxntree;\r\n\r\nimport org.junit.Test;\r\n\r\nimport competitive.programming.gamethe"
},
{
"path": "src/test/java/competitive/programming/gametheory/minimax/MinimaxTest.java",
"chars": 736,
"preview": "package competitive.programming.gametheory.minimax;\r\n\r\nimport org.junit.Test;\r\n\r\nimport competitive.programming.gametheo"
},
{
"path": "src/test/java/competitive/programming/gametheory/treesearch/TreeSearchTest.java",
"chars": 4083,
"preview": "package competitive.programming.gametheory.treesearch;\r\n\r\nimport static org.junit.Assert.assertEquals;\r\nimport static or"
},
{
"path": "src/test/java/competitive/programming/genetic/GeneticAlgorithmTest.java",
"chars": 4050,
"preview": "package competitive.programming.genetic;\r\n\r\nimport static org.junit.Assert.assertEquals;\r\n\r\nimport java.util.Collections"
},
{
"path": "src/test/java/competitive/programming/geometry/CoordTest.java",
"chars": 880,
"preview": "package competitive.programming.geometry;\r\n\r\nimport static org.junit.Assert.assertEquals;\r\n\r\nimport org.junit.Test;\r\n\r\np"
},
{
"path": "src/test/java/competitive/programming/geometry/VectorTest.java",
"chars": 872,
"preview": "package competitive.programming.geometry;\r\n\r\nimport static org.junit.Assert.*;\r\n\r\nimport org.junit.Test;\r\n\r\nimport compe"
},
{
"path": "src/test/java/competitive/programming/graph/GraphTest.java",
"chars": 3848,
"preview": "package competitive.programming.graph;\r\n\r\nimport static org.junit.Assert.assertArrayEquals;\r\n\r\nimport java.util.ArrayLis"
},
{
"path": "src/test/java/competitive/programming/math/QuadraticEquationTest.java",
"chars": 994,
"preview": "package competitive.programming.math;\r\n\r\nimport static org.junit.Assert.*;\r\n\r\nimport java.util.Arrays;\r\n\r\nimport org.jun"
},
{
"path": "src/test/java/competitive/programming/physics/DiskTest.java",
"chars": 2367,
"preview": "package competitive.programming.physics;\r\n\r\nimport static org.junit.Assert.*;\r\n\r\nimport org.junit.Test;\r\n\r\nimport compet"
},
{
"path": "src/test/java/competitive/programming/timemanagement/TimerTest.java",
"chars": 1464,
"preview": "package competitive.programming.timemanagement;\r\n\r\nimport static org.junit.Assert.fail;\r\n\r\nimport org.junit.Test;\r\n\r\npub"
}
]
// ... and 8 more files (download for full content)
About this extraction
This page contains the full source code of the Manwe56/competitive-programming GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 105 files (27.2 MB), approximately 323.4k tokens, and a symbol index with 801 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.