diff options
| -rw-r--r-- | client/js/app/yarn.lock | 54 | ||||
| -rw-r--r-- | dependency-versions/pom.xml | 4 | ||||
| -rw-r--r-- | flags/src/main/java/com/yahoo/vespa/flags/Flags.java | 7 | ||||
| -rw-r--r-- | searchlib/src/tests/query/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | searchlib/src/tests/query/streaming_query_test.cpp | 497 | ||||
| -rw-r--r-- | vespamalloc/src/vespamalloc/malloc/allocchunk.cpp | 14 | ||||
| -rw-r--r-- | vespamalloc/src/vespamalloc/malloc/globalpool.h | 5 | ||||
| -rw-r--r-- | vespamalloc/src/vespamalloc/malloc/globalpool.hpp | 11 |
8 files changed, 322 insertions, 271 deletions
diff --git a/client/js/app/yarn.lock b/client/js/app/yarn.lock index b7a77e10561..a647f8a22cd 100644 --- a/client/js/app/yarn.lock +++ b/client/js/app/yarn.lock @@ -721,10 +721,10 @@ resolved "https://registry.yarnpkg.com/@eslint-community/regexpp/-/regexpp-4.10.0.tgz#548f6de556857c8bb73bbee70c35dc82a2e74d63" integrity sha512-Cu96Sd2By9mCNTx2iyKOmq10v22jUVQv0lQnlGNy16oE9589yE+QADPbrMGCkA51cKZSg3Pu/aTJVTGfL/qjUA== -"@eslint/eslintrc@^2.1.3": - version "2.1.3" - resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-2.1.3.tgz#797470a75fe0fbd5a53350ee715e85e87baff22d" - integrity sha512-yZzuIG+jnVu6hNSzFEN07e8BxF3uAzYtQb6uDkaYZLo6oYZDCq454c5kB8zxnzfCYyP4MIuyBn10L0DqwujTmA== +"@eslint/eslintrc@^2.1.4": + version "2.1.4" + resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-2.1.4.tgz#388a269f0f25c1b6adc317b5a2c55714894c70ad" + integrity sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ== dependencies: ajv "^6.12.4" debug "^4.3.2" @@ -736,10 +736,10 @@ minimatch "^3.1.2" strip-json-comments "^3.1.1" -"@eslint/js@8.54.0": - version "8.54.0" - resolved "https://registry.yarnpkg.com/@eslint/js/-/js-8.54.0.tgz#4fab9a2ff7860082c304f750e94acd644cf984cf" - integrity sha512-ut5V+D+fOoWPgGGNj83GGjnntO39xDy6DWxO0wb7Jp3DcMX0TfIqdzHF85VTQkerdyGmuuMD9AKAo5KiNlf/AQ== +"@eslint/js@8.55.0": + version "8.55.0" + resolved "https://registry.yarnpkg.com/@eslint/js/-/js-8.55.0.tgz#b721d52060f369aa259cf97392403cb9ce892ec6" + integrity sha512-qQfo2mxH5yVom1kacMtZZJFVdW+E70mqHMJvVg6WTLo+VBuQJ4TojZlfWBjK0ve5BdEeNAVxOsl/nvNMpJOaJA== "@floating-ui/core@^1.4.2": version "1.5.0" @@ -1269,10 +1269,10 @@ dependencies: "@babel/runtime" "^7.13.10" -"@remix-run/router@1.13.0": - version "1.13.0" - resolved "https://registry.yarnpkg.com/@remix-run/router/-/router-1.13.0.tgz#7e29c4ee85176d9c08cb0f4456bff74d092c5065" - integrity sha512-5dMOnVnefRsl4uRnAdoWjtVTdh8e6aZqgM4puy9nmEADH72ck+uXwzpJLEKE9Q6F8ZljNewLgmTfkxUrBdv4WA== +"@remix-run/router@1.13.1": + version "1.13.1" + resolved "https://registry.yarnpkg.com/@remix-run/router/-/router-1.13.1.tgz#07e2a8006f23a3bc898b3f317e0a58cc8076b86e" + integrity sha512-so+DHzZKsoOcoXrILB4rqDkMDy7NLMErRdOxvzvOKb507YINKUP4Di+shbTZDhSE/pBZ+vr7XGIpcOO0VLSA+Q== "@rollup/rollup-android-arm-eabi@4.6.0": version "4.6.0" @@ -2587,14 +2587,14 @@ eslint-visitor-keys@^3.3.0, eslint-visitor-keys@^3.4.1, eslint-visitor-keys@^3.4 integrity sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag== eslint@^8: - version "8.54.0" - resolved "https://registry.yarnpkg.com/eslint/-/eslint-8.54.0.tgz#588e0dd4388af91a2e8fa37ea64924074c783537" - integrity sha512-NY0DfAkM8BIZDVl6PgSa1ttZbx3xHgJzSNJKYcQglem6CppHyMhRIQkBVSSMaSRnLhig3jsDbEzOjwCVt4AmmA== + version "8.55.0" + resolved "https://registry.yarnpkg.com/eslint/-/eslint-8.55.0.tgz#078cb7b847d66f2c254ea1794fa395bf8e7e03f8" + integrity sha512-iyUUAM0PCKj5QpwGfmCAG9XXbZCWsqP/eWAWrG/W0umvjuLRBECwSFdt+rCntju0xEH7teIABPwXpahftIaTdA== dependencies: "@eslint-community/eslint-utils" "^4.2.0" "@eslint-community/regexpp" "^4.6.1" - "@eslint/eslintrc" "^2.1.3" - "@eslint/js" "8.54.0" + "@eslint/eslintrc" "^2.1.4" + "@eslint/js" "8.55.0" "@humanwhocodes/config-array" "^0.11.13" "@humanwhocodes/module-importer" "^1.0.1" "@nodelib/fs.walk" "^1.2.8" @@ -4808,19 +4808,19 @@ react-refresh@^0.14.0: integrity sha512-wViHqhAd8OHeLS/IRMJjTSDHF3U9eWi62F/MledQGPdJGDhodXJ9PBLNGr6WWL7qlH12Mt3TyTpbS+hGXMjCzQ== react-router-dom@^6: - version "6.20.0" - resolved "https://registry.yarnpkg.com/react-router-dom/-/react-router-dom-6.20.0.tgz#7b9527a1e29c7fb90736a5f89d54ca01f40e264b" - integrity sha512-CbcKjEyiSVpA6UtCHOIYLUYn/UJfwzp55va4yEfpk7JBN3GPqWfHrdLkAvNCcpXr8QoihcDMuk0dzWZxtlB/mQ== + version "6.20.1" + resolved "https://registry.yarnpkg.com/react-router-dom/-/react-router-dom-6.20.1.tgz#e34f8075b9304221420de3609e072bb349824984" + integrity sha512-npzfPWcxfQN35psS7rJgi/EW0Gx6EsNjfdJSAk73U/HqMEJZ2k/8puxfwHFgDQhBGmS3+sjnGbMdMSV45axPQw== dependencies: - "@remix-run/router" "1.13.0" - react-router "6.20.0" + "@remix-run/router" "1.13.1" + react-router "6.20.1" -react-router@6.20.0: - version "6.20.0" - resolved "https://registry.yarnpkg.com/react-router/-/react-router-6.20.0.tgz#4275a3567ecc55f7703073158048db10096bb539" - integrity sha512-pVvzsSsgUxxtuNfTHC4IxjATs10UaAtvLGVSA1tbUE4GDaOSU1Esu2xF5nWLz7KPiMuW8BJWuPFdlGYJ7/rW0w== +react-router@6.20.1: + version "6.20.1" + resolved "https://registry.yarnpkg.com/react-router/-/react-router-6.20.1.tgz#e8cc326031d235aaeec405bb234af77cf0fe75ef" + integrity sha512-ccvLrB4QeT5DlaxSFFYi/KR8UMQ4fcD8zBcR71Zp1kaYTC5oJKYAp1cbavzGrogwxca+ubjkd7XjFZKBW8CxPA== dependencies: - "@remix-run/router" "1.13.0" + "@remix-run/router" "1.13.1" react-textarea-autosize@8.3.4: version "8.3.4" diff --git a/dependency-versions/pom.xml b/dependency-versions/pom.xml index 29ac69f40a0..deb82e9e2c7 100644 --- a/dependency-versions/pom.xml +++ b/dependency-versions/pom.xml @@ -113,7 +113,7 @@ <junit.vespa.version>5.10.0</junit.vespa.version> <junit.platform.vespa.version>1.10.0</junit.platform.vespa.version> <junit4.vespa.version>4.13.2</junit4.vespa.version> - <luben.zstd.vespa.version>1.5.5-10</luben.zstd.vespa.version> + <luben.zstd.vespa.version>1.5.5-11</luben.zstd.vespa.version> <lucene.vespa.version>9.8.0</lucene.vespa.version> <maven-archiver.vespa.version>3.6.1</maven-archiver.vespa.version> <maven-wagon.vespa.version>3.5.3</maven-wagon.vespa.version> @@ -160,7 +160,7 @@ <maven-gpg-plugin.vespa.version>3.1.0</maven-gpg-plugin.vespa.version> <maven-install-plugin.vespa.version>3.1.1</maven-install-plugin.vespa.version> <maven-jar-plugin.vespa.version>3.3.0</maven-jar-plugin.vespa.version> - <maven-javadoc-plugin.vespa.version>3.6.2</maven-javadoc-plugin.vespa.version> + <maven-javadoc-plugin.vespa.version>3.6.3</maven-javadoc-plugin.vespa.version> <maven-plugin-api.vespa.version>${maven-core.vespa.version}</maven-plugin-api.vespa.version> <maven-plugin-tools.vespa.version>3.10.2</maven-plugin-tools.vespa.version> <maven-resources-plugin.vespa.version>3.3.1</maven-resources-plugin.vespa.version> diff --git a/flags/src/main/java/com/yahoo/vespa/flags/Flags.java b/flags/src/main/java/com/yahoo/vespa/flags/Flags.java index 6c2ebe277e2..c486f239bef 100644 --- a/flags/src/main/java/com/yahoo/vespa/flags/Flags.java +++ b/flags/src/main/java/com/yahoo/vespa/flags/Flags.java @@ -439,6 +439,13 @@ public class Flags { "Takes effect immediately", CONSOLE_USER_EMAIL); + public static final UnboundBooleanFlag RESTART_ON_DEPLOY_WHEN_ONNX_MODEL_CHANGES = defineFeatureFlag( + "restart-on-deploy-when-onnx-model-changes", false, + List.of("hmusum"), "2023-12-04", "2024-01-04", + "If set, restart on deploy if onnx model or onnx model options used by a container cluster change", + "Takes effect at redeployment", + INSTANCE_ID); + /** WARNING: public for testing: All flags should be defined in {@link Flags}. */ public static UnboundBooleanFlag defineFeatureFlag(String flagId, boolean defaultValue, List<String> owners, String createdAt, String expiresAt, String description, diff --git a/searchlib/src/tests/query/CMakeLists.txt b/searchlib/src/tests/query/CMakeLists.txt index 2b56129277c..0cb6c9413b0 100644 --- a/searchlib/src/tests/query/CMakeLists.txt +++ b/searchlib/src/tests/query/CMakeLists.txt @@ -39,6 +39,7 @@ vespa_add_executable(searchlib_streaming_query_test_app TEST streaming_query_test.cpp DEPENDS searchlib + GTest::gtest ) vespa_add_test(NAME searchlib_streaming_query_test_app COMMAND searchlib_streaming_query_test_app) vespa_add_executable(searchlib_streaming_query_large_test_app TEST diff --git a/searchlib/src/tests/query/streaming_query_test.cpp b/searchlib/src/tests/query/streaming_query_test.cpp index ffd8c21d561..020afc484e0 100644 --- a/searchlib/src/tests/query/streaming_query_test.cpp +++ b/searchlib/src/tests/query/streaming_query_test.cpp @@ -5,7 +5,7 @@ #include <vespa/searchlib/query/tree/querybuilder.h> #include <vespa/searchlib/query/tree/simplequery.h> #include <vespa/searchlib/query/tree/stackdumpcreator.h> -#include <vespa/vespalib/testkit/test_kit.h> +#include <vespa/vespalib/gtest/gtest.h> #include <limits> #include <cmath> @@ -15,12 +15,13 @@ using namespace search::streaming; using TermType = QueryTerm::Type; void assertHit(const Hit & h, size_t expWordpos, size_t expContext, int32_t weight) { - EXPECT_EQUAL(h.wordpos(), expWordpos); - EXPECT_EQUAL(h.context(), expContext); - EXPECT_EQUAL(h.weight(), weight); + EXPECT_EQ(h.wordpos(), expWordpos); + EXPECT_EQ(h.context(), expContext); + EXPECT_EQ(h.weight(), weight); } -TEST("testQueryLanguage") { +TEST(StreamingQueryTest, test_query_language) +{ QueryNodeResultFactory factory; int64_t ia(0), ib(0); double da(0), db(0); @@ -28,209 +29,209 @@ TEST("testQueryLanguage") { { QueryTerm q(factory.create(), "7", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); - EXPECT_EQUAL(ia, 7); - EXPECT_EQUAL(ib, 7); + EXPECT_EQ(ia, 7); + EXPECT_EQ(ib, 7); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, 7); - EXPECT_EQUAL(db, 7); + EXPECT_EQ(da, 7); + EXPECT_EQ(db, 7); } { QueryTerm q(factory.create(), "-7", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); - EXPECT_EQUAL(ia, -7); - EXPECT_EQUAL(ib, -7); + EXPECT_EQ(ia, -7); + EXPECT_EQ(ib, -7); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, -7); - EXPECT_EQUAL(db, -7); + EXPECT_EQ(da, -7); + EXPECT_EQ(db, -7); } { QueryTerm q(factory.create(), "7.5", "index", TermType::WORD); EXPECT_TRUE(!q.getAsIntegerTerm(ia, ib)); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, 7.5); - EXPECT_EQUAL(db, 7.5); + EXPECT_EQ(da, 7.5); + EXPECT_EQ(db, 7.5); } { QueryTerm q(factory.create(), "-7.5", "index", TermType::WORD); EXPECT_TRUE(!q.getAsIntegerTerm(ia, ib)); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, -7.5); - EXPECT_EQUAL(db, -7.5); + EXPECT_EQ(da, -7.5); + EXPECT_EQ(db, -7.5); } { QueryTerm q(factory.create(), "<7", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); - EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min()); - EXPECT_EQUAL(ib, 6); + EXPECT_EQ(ia, std::numeric_limits<int64_t>::min()); + EXPECT_EQ(ib, 6); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, -std::numeric_limits<double>::max()); - EXPECT_LESS(db, 7); - EXPECT_GREATER(db, 6.99); + EXPECT_EQ(da, -std::numeric_limits<double>::max()); + EXPECT_LT(db, 7); + EXPECT_GT(db, 6.99); } { QueryTerm q(factory.create(), "[;7]", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); - EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min()); - EXPECT_EQUAL(ib, 7); + EXPECT_EQ(ia, std::numeric_limits<int64_t>::min()); + EXPECT_EQ(ib, 7); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, -std::numeric_limits<double>::max()); - EXPECT_EQUAL(db, 7); + EXPECT_EQ(da, -std::numeric_limits<double>::max()); + EXPECT_EQ(db, 7); } { QueryTerm q(factory.create(), ">7", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); - EXPECT_EQUAL(ia, 8); - EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max()); + EXPECT_EQ(ia, 8); + EXPECT_EQ(ib, std::numeric_limits<int64_t>::max()); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_GREATER(da, 7); - EXPECT_LESS(da, 7.01); - EXPECT_EQUAL(db, std::numeric_limits<double>::max()); + EXPECT_GT(da, 7); + EXPECT_LT(da, 7.01); + EXPECT_EQ(db, std::numeric_limits<double>::max()); } { QueryTerm q(factory.create(), "[7;]", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); - EXPECT_EQUAL(ia, 7); - EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max()); + EXPECT_EQ(ia, 7); + EXPECT_EQ(ib, std::numeric_limits<int64_t>::max()); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, 7); - EXPECT_EQUAL(db, std::numeric_limits<double>::max()); + EXPECT_EQ(da, 7); + EXPECT_EQ(db, std::numeric_limits<double>::max()); } { QueryTerm q(factory.create(), "[-7;7]", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); - EXPECT_EQUAL(ia, -7); - EXPECT_EQUAL(ib, 7); + EXPECT_EQ(ia, -7); + EXPECT_EQ(ib, 7); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, -7); - EXPECT_EQUAL(db, 7); + EXPECT_EQ(da, -7); + EXPECT_EQ(db, 7); } { QueryTerm q(factory.create(), "[-7.1;7.1]", "index", TermType::WORD); EXPECT_FALSE(q.getAsIntegerTerm(ia, ib)); // This is dubious and perhaps a regression. - EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min()); - EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max()); + EXPECT_EQ(ia, std::numeric_limits<int64_t>::min()); + EXPECT_EQ(ib, std::numeric_limits<int64_t>::max()); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, -7.1); - EXPECT_EQUAL(db, 7.1); + EXPECT_EQ(da, -7.1); + EXPECT_EQ(db, 7.1); } { QueryTerm q(factory.create(), "[500.0;1.7976931348623157E308]", "index", TermType::WORD); EXPECT_FALSE(q.getAsIntegerTerm(ia, ib)); // This is dubious and perhaps a regression. - EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min()); - EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max()); + EXPECT_EQ(ia, std::numeric_limits<int64_t>::min()); + EXPECT_EQ(ib, std::numeric_limits<int64_t>::max()); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, 500.0); - EXPECT_EQUAL(db, std::numeric_limits<double>::max()); + EXPECT_EQ(da, 500.0); + EXPECT_EQ(db, std::numeric_limits<double>::max()); } const double minusSeven(-7), seven(7); { QueryTerm q(factory.create(), "<-7;7]", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); - EXPECT_EQUAL(ia, -6); - EXPECT_EQUAL(ib, 7); + EXPECT_EQ(ia, -6); + EXPECT_EQ(ib, 7); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, std::nextafterf(minusSeven, seven)); - EXPECT_EQUAL(db, seven); + EXPECT_EQ(da, std::nextafterf(minusSeven, seven)); + EXPECT_EQ(db, seven); } { QueryTerm q(factory.create(), "<-7;7>", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); - EXPECT_EQUAL(ia, -6); - EXPECT_EQUAL(ib, 6); + EXPECT_EQ(ia, -6); + EXPECT_EQ(ib, 6); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, std::nextafterf(minusSeven, seven)); - EXPECT_EQUAL(db, std::nextafterf(seven, minusSeven)); + EXPECT_EQ(da, std::nextafterf(minusSeven, seven)); + EXPECT_EQ(db, std::nextafterf(seven, minusSeven)); } { QueryTerm q(factory.create(), "<1;2>", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); - EXPECT_EQUAL(ia, 2); - EXPECT_EQUAL(ib, 1); + EXPECT_EQ(ia, 2); + EXPECT_EQ(ib, 1); } { QueryTerm q(factory.create(), "[-7;7>", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); - EXPECT_EQUAL(ia, -7); - EXPECT_EQUAL(ib, 6); + EXPECT_EQ(ia, -7); + EXPECT_EQ(ib, 6); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, minusSeven); - EXPECT_EQUAL(db, std::nextafterf(seven, minusSeven)); + EXPECT_EQ(da, minusSeven); + EXPECT_EQ(db, std::nextafterf(seven, minusSeven)); } { QueryTerm q(factory.create(), "<-7", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); - EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min()); - EXPECT_EQUAL(ib, -8); + EXPECT_EQ(ia, std::numeric_limits<int64_t>::min()); + EXPECT_EQ(ib, -8); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, -std::numeric_limits<double>::max()); - EXPECT_LESS(db, -7); - EXPECT_GREATER(db, -7.01); + EXPECT_EQ(da, -std::numeric_limits<double>::max()); + EXPECT_LT(db, -7); + EXPECT_GT(db, -7.01); } { QueryTerm q(factory.create(), "[;-7]", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); - EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min()); - EXPECT_EQUAL(ib, -7); + EXPECT_EQ(ia, std::numeric_limits<int64_t>::min()); + EXPECT_EQ(ib, -7); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, -std::numeric_limits<double>::max()); - EXPECT_EQUAL(db, -7); + EXPECT_EQ(da, -std::numeric_limits<double>::max()); + EXPECT_EQ(db, -7); } { QueryTerm q(factory.create(), "<;-7]", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); - EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min()); - EXPECT_EQUAL(ib, -7); + EXPECT_EQ(ia, std::numeric_limits<int64_t>::min()); + EXPECT_EQ(ib, -7); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, -std::numeric_limits<double>::max()); - EXPECT_EQUAL(db, -7); + EXPECT_EQ(da, -std::numeric_limits<double>::max()); + EXPECT_EQ(db, -7); } { QueryTerm q(factory.create(), ">-7", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); - EXPECT_EQUAL(ia, -6); - EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max()); + EXPECT_EQ(ia, -6); + EXPECT_EQ(ib, std::numeric_limits<int64_t>::max()); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_GREATER(da, -7); - EXPECT_LESS(da, -6.99); - EXPECT_EQUAL(db, std::numeric_limits<double>::max()); + EXPECT_GT(da, -7); + EXPECT_LT(da, -6.99); + EXPECT_EQ(db, std::numeric_limits<double>::max()); } { QueryTerm q(factory.create(), "[-7;]", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); - EXPECT_EQUAL(ia, -7); - EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max()); + EXPECT_EQ(ia, -7); + EXPECT_EQ(ib, std::numeric_limits<int64_t>::max()); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, -7); - EXPECT_EQUAL(db, std::numeric_limits<double>::max()); + EXPECT_EQ(da, -7); + EXPECT_EQ(db, std::numeric_limits<double>::max()); } { QueryTerm q(factory.create(), "[-7;>", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); - EXPECT_EQUAL(ia, -7); - EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max()); + EXPECT_EQ(ia, -7); + EXPECT_EQ(ib, std::numeric_limits<int64_t>::max()); EXPECT_TRUE(q.getAsDoubleTerm(da, db)); - EXPECT_EQUAL(da, -7); - EXPECT_EQUAL(db, std::numeric_limits<double>::max()); + EXPECT_EQ(da, -7); + EXPECT_EQ(db, std::numeric_limits<double>::max()); } { @@ -284,76 +285,80 @@ public: const char TERM_UNIQ = static_cast<char>(ParseItem::ITEM_TERM) | static_cast<char>(ParseItem::IF_UNIQUEID); -TEST("e is not rewritten even if allowed") { +TEST(StreamingQueryTest, e_is_not_rewritten_even_if_allowed) +{ const char term[6] = {TERM_UNIQ, 3, 1, 'c', 1, 'e'}; vespalib::stringref stackDump(term, sizeof(term)); - EXPECT_EQUAL(6u, stackDump.size()); + EXPECT_EQ(6u, stackDump.size()); AllowRewrite allowRewrite; const Query q(allowRewrite, stackDump); EXPECT_TRUE(q.valid()); const QueryNode & root = q.getRoot(); EXPECT_TRUE(dynamic_cast<const QueryTerm *>(&root) != nullptr); const QueryTerm & qt = static_cast<const QueryTerm &>(root); - EXPECT_EQUAL("c", qt.index()); - EXPECT_EQUAL(vespalib::stringref("e"), qt.getTerm()); - EXPECT_EQUAL(3u, qt.uniqueId()); + EXPECT_EQ("c", qt.index()); + EXPECT_EQ(vespalib::stringref("e"), qt.getTerm()); + EXPECT_EQ(3u, qt.uniqueId()); } -TEST("1.0e is not rewritten by default") { +TEST(StreamingQueryTest, onedot0e_is_not_rewritten_by_default) +{ const char term[9] = {TERM_UNIQ, 3, 1, 'c', 4, '1', '.', '0', 'e'}; vespalib::stringref stackDump(term, sizeof(term)); - EXPECT_EQUAL(9u, stackDump.size()); + EXPECT_EQ(9u, stackDump.size()); QueryNodeResultFactory empty; const Query q(empty, stackDump); EXPECT_TRUE(q.valid()); const QueryNode & root = q.getRoot(); EXPECT_TRUE(dynamic_cast<const QueryTerm *>(&root) != nullptr); const QueryTerm & qt = static_cast<const QueryTerm &>(root); - EXPECT_EQUAL("c", qt.index()); - EXPECT_EQUAL(vespalib::stringref("1.0e"), qt.getTerm()); - EXPECT_EQUAL(3u, qt.uniqueId()); + EXPECT_EQ("c", qt.index()); + EXPECT_EQ(vespalib::stringref("1.0e"), qt.getTerm()); + EXPECT_EQ(3u, qt.uniqueId()); } -TEST("1.0e is rewritten if allowed too.") { +TEST(StreamingQueryTest, onedot0e_is_rewritten_if_allowed_too) +{ const char term[9] = {TERM_UNIQ, 3, 1, 'c', 4, '1', '.', '0', 'e'}; vespalib::stringref stackDump(term, sizeof(term)); - EXPECT_EQUAL(9u, stackDump.size()); + EXPECT_EQ(9u, stackDump.size()); AllowRewrite empty; const Query q(empty, stackDump); EXPECT_TRUE(q.valid()); const QueryNode & root = q.getRoot(); EXPECT_TRUE(dynamic_cast<const EquivQueryNode *>(&root) != nullptr); const EquivQueryNode & equiv = static_cast<const EquivQueryNode &>(root); - EXPECT_EQUAL(2u, equiv.size()); + EXPECT_EQ(2u, equiv.size()); EXPECT_TRUE(dynamic_cast<const QueryTerm *>(equiv[0].get()) != nullptr); { const QueryTerm & qt = static_cast<const QueryTerm &>(*equiv[0]); - EXPECT_EQUAL("c", qt.index()); - EXPECT_EQUAL(vespalib::stringref("1.0e"), qt.getTerm()); - EXPECT_EQUAL(3u, qt.uniqueId()); + EXPECT_EQ("c", qt.index()); + EXPECT_EQ(vespalib::stringref("1.0e"), qt.getTerm()); + EXPECT_EQ(3u, qt.uniqueId()); } EXPECT_TRUE(dynamic_cast<const PhraseQueryNode *>(equiv[1].get()) != nullptr); { const PhraseQueryNode & phrase = static_cast<const PhraseQueryNode &>(*equiv[1]); - EXPECT_EQUAL(2u, phrase.size()); + EXPECT_EQ(2u, phrase.size()); EXPECT_TRUE(dynamic_cast<const QueryTerm *>(phrase[0].get()) != nullptr); { const QueryTerm & qt = static_cast<const QueryTerm &>(*phrase[0]); - EXPECT_EQUAL("c", qt.index()); - EXPECT_EQUAL(vespalib::stringref("1"), qt.getTerm()); - EXPECT_EQUAL(0u, qt.uniqueId()); + EXPECT_EQ("c", qt.index()); + EXPECT_EQ(vespalib::stringref("1"), qt.getTerm()); + EXPECT_EQ(0u, qt.uniqueId()); } EXPECT_TRUE(dynamic_cast<const QueryTerm *>(phrase[1].get()) != nullptr); { const QueryTerm & qt = static_cast<const QueryTerm &>(*phrase[1]); - EXPECT_EQUAL("c", qt.index()); - EXPECT_EQUAL(vespalib::stringref("0e"), qt.getTerm()); - EXPECT_EQUAL(0u, qt.uniqueId()); + EXPECT_EQ("c", qt.index()); + EXPECT_EQ(vespalib::stringref("0e"), qt.getTerm()); + EXPECT_EQ(0u, qt.uniqueId()); } } } -TEST("testGetQueryParts") { +TEST(StreamingQueryTest, test_get_query_parts) +{ QueryBuilder<SimpleQueryNodeTypes> builder; builder.addAnd(4); { @@ -387,7 +392,7 @@ TEST("testGetQueryParts") { phrases[0]->getLeaves(pts); ASSERT_TRUE(pts.size() == 3); for (size_t i = 0; i < 3; ++i) { - EXPECT_EQUAL(pts[i], terms[i + 1]); + EXPECT_EQ(pts[i], terms[i + 1]); } } { @@ -395,12 +400,13 @@ TEST("testGetQueryParts") { phrases[1]->getLeaves(pts); ASSERT_TRUE(pts.size() == 2); for (size_t i = 0; i < 2; ++i) { - EXPECT_EQUAL(pts[i], terms[i + 5]); + EXPECT_EQ(pts[i], terms[i + 5]); } } } -TEST("testPhraseEvaluate") { +TEST(StreamingQueryTest, test_phrase_evaluate) +{ QueryBuilder<SimpleQueryNodeTypes> builder; builder.addPhrase(3, "", 0, Weight(0)); { @@ -449,26 +455,27 @@ TEST("testPhraseEvaluate") { HitList hits; PhraseQueryNode * p = static_cast<PhraseQueryNode *>(phrases[0]); p->evaluateHits(hits); - ASSERT_EQUAL(3u, hits.size()); - EXPECT_EQUAL(hits[0].wordpos(), 2u); - EXPECT_EQUAL(hits[0].context(), 0u); - EXPECT_EQUAL(hits[1].wordpos(), 6u); - EXPECT_EQUAL(hits[1].context(), 1u); - EXPECT_EQUAL(hits[2].wordpos(), 2u); - EXPECT_EQUAL(hits[2].context(), 3u); - ASSERT_EQUAL(4u, p->getFieldInfoSize()); - EXPECT_EQUAL(p->getFieldInfo(0).getHitOffset(), 0u); - EXPECT_EQUAL(p->getFieldInfo(0).getHitCount(), 1u); - EXPECT_EQUAL(p->getFieldInfo(1).getHitOffset(), 1u); - EXPECT_EQUAL(p->getFieldInfo(1).getHitCount(), 1u); - EXPECT_EQUAL(p->getFieldInfo(2).getHitOffset(), 0u); // invalid, but will never be used - EXPECT_EQUAL(p->getFieldInfo(2).getHitCount(), 0u); - EXPECT_EQUAL(p->getFieldInfo(3).getHitOffset(), 2u); - EXPECT_EQUAL(p->getFieldInfo(3).getHitCount(), 1u); + ASSERT_EQ(3u, hits.size()); + EXPECT_EQ(hits[0].wordpos(), 2u); + EXPECT_EQ(hits[0].context(), 0u); + EXPECT_EQ(hits[1].wordpos(), 6u); + EXPECT_EQ(hits[1].context(), 1u); + EXPECT_EQ(hits[2].wordpos(), 2u); + EXPECT_EQ(hits[2].context(), 3u); + ASSERT_EQ(4u, p->getFieldInfoSize()); + EXPECT_EQ(p->getFieldInfo(0).getHitOffset(), 0u); + EXPECT_EQ(p->getFieldInfo(0).getHitCount(), 1u); + EXPECT_EQ(p->getFieldInfo(1).getHitOffset(), 1u); + EXPECT_EQ(p->getFieldInfo(1).getHitCount(), 1u); + EXPECT_EQ(p->getFieldInfo(2).getHitOffset(), 0u); // invalid, but will never be used + EXPECT_EQ(p->getFieldInfo(2).getHitCount(), 0u); + EXPECT_EQ(p->getFieldInfo(3).getHitOffset(), 2u); + EXPECT_EQ(p->getFieldInfo(3).getHitCount(), 1u); EXPECT_TRUE(p->evaluate()); } -TEST("testHit") { +TEST(StreamingQueryTest, test_hit) +{ // positions (0 - (2^24-1)) assertHit(Hit(0, 0, 0, 0), 0, 0, 0); assertHit(Hit(256, 0, 0, 1), 256, 0, 1); @@ -484,31 +491,32 @@ TEST("testHit") { void assertInt8Range(const std::string &term, bool expAdjusted, int64_t expLow, int64_t expHigh) { QueryTermSimple q(term, TermType::WORD); QueryTermSimple::RangeResult<int8_t> res = q.getRange<int8_t>(); - EXPECT_EQUAL(true, res.valid); - EXPECT_EQUAL(expAdjusted, res.adjusted); - EXPECT_EQUAL(expLow, (int64_t)res.low); - EXPECT_EQUAL(expHigh, (int64_t)res.high); + EXPECT_EQ(true, res.valid); + EXPECT_EQ(expAdjusted, res.adjusted); + EXPECT_EQ(expLow, (int64_t)res.low); + EXPECT_EQ(expHigh, (int64_t)res.high); } void assertInt32Range(const std::string &term, bool expAdjusted, int64_t expLow, int64_t expHigh) { QueryTermSimple q(term, TermType::WORD); QueryTermSimple::RangeResult<int32_t> res = q.getRange<int32_t>(); - EXPECT_EQUAL(true, res.valid); - EXPECT_EQUAL(expAdjusted, res.adjusted); - EXPECT_EQUAL(expLow, (int64_t)res.low); - EXPECT_EQUAL(expHigh, (int64_t)res.high); + EXPECT_EQ(true, res.valid); + EXPECT_EQ(expAdjusted, res.adjusted); + EXPECT_EQ(expLow, (int64_t)res.low); + EXPECT_EQ(expHigh, (int64_t)res.high); } void assertInt64Range(const std::string &term, bool expAdjusted, int64_t expLow, int64_t expHigh) { QueryTermSimple q(term, TermType::WORD); QueryTermSimple::RangeResult<int64_t> res = q.getRange<int64_t>(); - EXPECT_EQUAL(true, res.valid); - EXPECT_EQUAL(expAdjusted, res.adjusted); - EXPECT_EQUAL(expLow, (int64_t)res.low); - EXPECT_EQUAL(expHigh, (int64_t)res.high); + EXPECT_EQ(true, res.valid); + EXPECT_EQ(expAdjusted, res.adjusted); + EXPECT_EQ(expLow, (int64_t)res.low); + EXPECT_EQ(expHigh, (int64_t)res.high); } -TEST("requireThatInt8LimitsAreEnforced") { +TEST(StreamingQueryTest, require_that_int8_limits_are_enforced) +{ //std::numeric_limits<int8_t>::min() -> -128 //std::numeric_limits<int8_t>::max() -> 127 @@ -525,7 +533,8 @@ TEST("requireThatInt8LimitsAreEnforced") { assertInt8Range("[-129;128]", true, -128, 127); } -TEST("requireThatInt32LimitsAreEnforced") { +TEST(StreamingQueryTest, require_that_int32_limits_are_enforced) +{ //std::numeric_limits<int32_t>::min() -> -2147483648 //std::numeric_limits<int32_t>::max() -> 2147483647 @@ -545,7 +554,8 @@ TEST("requireThatInt32LimitsAreEnforced") { assertInt32Range("[-2147483649;2147483648]", true, min, max); } -TEST("requireThatInt64LimitsAreEnforced") { +TEST(StreamingQueryTest, require_that_int64_limits_are_enforced) +{ //std::numeric_limits<int64_t>::min() -> -9223372036854775808 //std::numeric_limits<int64_t>::max() -> 9223372036854775807 @@ -565,13 +575,15 @@ TEST("requireThatInt64LimitsAreEnforced") { assertInt64Range("[-9223372036854775809;9223372036854775808]", false, min, max); } -TEST("require sensible rounding when using integer attributes.") { +TEST(StreamingQueryTest, require_sensible_rounding_when_using_integer_attributes) +{ assertInt64Range("1.2", false, 1, 1); assertInt64Range("1.51", false, 2, 2); assertInt64Range("2.49", false, 2, 2); } -TEST("require that we can take floating point values in range search too.") { +TEST(StreamingQueryTest, require_that_we_can_take_floating_point_values_in_range_search_too) +{ assertInt64Range("[1;2]", false, 1, 2); assertInt64Range("[1.1;2.1]", false, 2, 2); assertInt64Range("[1.9;3.9]", false, 2, 3); @@ -588,7 +600,8 @@ TEST("require that we can take floating point values in range search too.") { assertInt64Range("[1.7976931348623157E308;-1.7976931348623157E308]", false, std::numeric_limits<int64_t>::max(), std::numeric_limits<int64_t>::min()); } -TEST("require that we handle empty range as expected") { +TEST(StreamingQueryTest, require_that_we_handle_empty_range_as_expected) +{ assertInt64Range("[1;1]", false, 1, 1); assertInt64Range("<1;1]", false, 2, 1); assertInt64Range("[0;1>", false, 0, 0); @@ -596,7 +609,8 @@ TEST("require that we handle empty range as expected") { assertInt64Range("<1;1>", false, 2, 0); } -TEST("require that ascending range can be specified with limit only") { +TEST(StreamingQueryTest, require_that_ascending_range_can_be_specified_with_limit_only) +{ int64_t low_integer = 0; int64_t high_integer = 0; double low_double = 0.0; @@ -607,14 +621,15 @@ TEST("require that ascending range can be specified with limit only") { EXPECT_TRUE(ascending_query.getAsIntegerTerm(low_integer, high_integer)); EXPECT_TRUE(ascending_query.getAsDoubleTerm(low_double, high_double)); - EXPECT_EQUAL(std::numeric_limits<int64_t>::min(), low_integer); - EXPECT_EQUAL(std::numeric_limits<int64_t>::max(), high_integer); - EXPECT_EQUAL(-std::numeric_limits<double>::max(), low_double); - EXPECT_EQUAL(std::numeric_limits<double>::max(), high_double); - EXPECT_EQUAL(500, ascending_query.getRangeLimit()); + EXPECT_EQ(std::numeric_limits<int64_t>::min(), low_integer); + EXPECT_EQ(std::numeric_limits<int64_t>::max(), high_integer); + EXPECT_EQ(-std::numeric_limits<double>::max(), low_double); + EXPECT_EQ(std::numeric_limits<double>::max(), high_double); + EXPECT_EQ(500, ascending_query.getRangeLimit()); } -TEST("require that descending range can be specified with limit only") { +TEST(StreamingQueryTest, require_that_descending_range_can_be_specified_with_limit_only) +{ int64_t low_integer = 0; int64_t high_integer = 0; double low_double = 0.0; @@ -625,102 +640,111 @@ TEST("require that descending range can be specified with limit only") { EXPECT_TRUE(descending_query.getAsIntegerTerm(low_integer, high_integer)); EXPECT_TRUE(descending_query.getAsDoubleTerm(low_double, high_double)); - EXPECT_EQUAL(std::numeric_limits<int64_t>::min(), low_integer); - EXPECT_EQUAL(std::numeric_limits<int64_t>::max(), high_integer); - EXPECT_EQUAL(-std::numeric_limits<double>::max(), low_double); - EXPECT_EQUAL(std::numeric_limits<double>::max(), high_double); - EXPECT_EQUAL(-500, descending_query.getRangeLimit()); + EXPECT_EQ(std::numeric_limits<int64_t>::min(), low_integer); + EXPECT_EQ(std::numeric_limits<int64_t>::max(), high_integer); + EXPECT_EQ(-std::numeric_limits<double>::max(), low_double); + EXPECT_EQ(std::numeric_limits<double>::max(), high_double); + EXPECT_EQ(-500, descending_query.getRangeLimit()); } -TEST("require that correctly specified diversity can be parsed") { +TEST(StreamingQueryTest, require_that_correctly_specified_diversity_can_be_parsed) +{ QueryNodeResultFactory eqnr; QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78]", "index", TermType::WORD); EXPECT_TRUE(descending_query.isValid()); - EXPECT_EQUAL(-500, descending_query.getRangeLimit()); - EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute()); - EXPECT_EQUAL(78u, descending_query.getMaxPerGroup()); - EXPECT_EQUAL(std::numeric_limits<uint32_t>::max(), descending_query.getDiversityCutoffGroups()); + EXPECT_EQ(-500, descending_query.getRangeLimit()); + EXPECT_EQ("ab56", descending_query.getDiversityAttribute()); + EXPECT_EQ(78u, descending_query.getMaxPerGroup()); + EXPECT_EQ(std::numeric_limits<uint32_t>::max(), descending_query.getDiversityCutoffGroups()); EXPECT_FALSE(descending_query.getDiversityCutoffStrict()); } -TEST("require that correctly specified diversity with cutoff groups can be parsed") { +TEST(StreamingQueryTest, require_that_correctly_specified_diversity_with_cutoff_groups_can_be_parsed) +{ QueryNodeResultFactory eqnr; QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;93]", "index", TermType::WORD); EXPECT_TRUE(descending_query.isValid()); - EXPECT_EQUAL(-500, descending_query.getRangeLimit()); - EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute()); - EXPECT_EQUAL(78u, descending_query.getMaxPerGroup()); - EXPECT_EQUAL(93u, descending_query.getDiversityCutoffGroups()); + EXPECT_EQ(-500, descending_query.getRangeLimit()); + EXPECT_EQ("ab56", descending_query.getDiversityAttribute()); + EXPECT_EQ(78u, descending_query.getMaxPerGroup()); + EXPECT_EQ(93u, descending_query.getDiversityCutoffGroups()); EXPECT_FALSE(descending_query.getDiversityCutoffStrict()); } -TEST("require that correctly specified diversity with cutoff groups can be parsed") { +TEST(StreamingQueryTest, require_that_correctly_specified_diversity_with_cutoff_groups_can_be_parsed_2) +{ QueryNodeResultFactory eqnr; QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;13]", "index", TermType::WORD); EXPECT_TRUE(descending_query.isValid()); - EXPECT_EQUAL(-500, descending_query.getRangeLimit()); - EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute()); - EXPECT_EQUAL(78u, descending_query.getMaxPerGroup()); - EXPECT_EQUAL(13u, descending_query.getDiversityCutoffGroups()); + EXPECT_EQ(-500, descending_query.getRangeLimit()); + EXPECT_EQ("ab56", descending_query.getDiversityAttribute()); + EXPECT_EQ(78u, descending_query.getMaxPerGroup()); + EXPECT_EQ(13u, descending_query.getDiversityCutoffGroups()); EXPECT_FALSE(descending_query.getDiversityCutoffStrict()); } -TEST("require that correctly specified diversity with incorrect cutoff groups can be parsed") { +TEST(StreamingQueryTest, require_that_correctly_specified_diversity_with_incorrect_cutoff_groups_can_be_parsed) +{ QueryNodeResultFactory eqnr; QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;a13.9]", "index", TermType::WORD); EXPECT_TRUE(descending_query.isValid()); - EXPECT_EQUAL(-500, descending_query.getRangeLimit()); - EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute()); - EXPECT_EQUAL(78u, descending_query.getMaxPerGroup()); - EXPECT_EQUAL(std::numeric_limits<uint32_t>::max(), descending_query.getDiversityCutoffGroups()); + EXPECT_EQ(-500, descending_query.getRangeLimit()); + EXPECT_EQ("ab56", descending_query.getDiversityAttribute()); + EXPECT_EQ(78u, descending_query.getMaxPerGroup()); + EXPECT_EQ(std::numeric_limits<uint32_t>::max(), descending_query.getDiversityCutoffGroups()); EXPECT_FALSE(descending_query.getDiversityCutoffStrict()); } -TEST("require that correctly specified diversity with cutoff strategy can be parsed") { +TEST(StreamingQueryTest, require_that_correctly_specified_diversity_with_cutoff_strategy_can_be_parsed) +{ QueryNodeResultFactory eqnr; QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;93;anything but strict]", "index", TermType::WORD); EXPECT_TRUE(descending_query.isValid()); - EXPECT_EQUAL(-500, descending_query.getRangeLimit()); - EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute()); - EXPECT_EQUAL(78u, descending_query.getMaxPerGroup()); - EXPECT_EQUAL(93u, descending_query.getDiversityCutoffGroups()); + EXPECT_EQ(-500, descending_query.getRangeLimit()); + EXPECT_EQ("ab56", descending_query.getDiversityAttribute()); + EXPECT_EQ(78u, descending_query.getMaxPerGroup()); + EXPECT_EQ(93u, descending_query.getDiversityCutoffGroups()); EXPECT_FALSE(descending_query.getDiversityCutoffStrict()); } -TEST("require that correctly specified diversity with strict cutoff strategy can be parsed") { +TEST(StreamingQueryTest, require_that_correctly_specified_diversity_with_strict_cutoff_strategy_can_be_parsed) +{ QueryNodeResultFactory eqnr; QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;93;strict]", "index", TermType::WORD); EXPECT_TRUE(descending_query.isValid()); - EXPECT_EQUAL(-500, descending_query.getRangeLimit()); - EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute()); - EXPECT_EQUAL(78u, descending_query.getMaxPerGroup()); - EXPECT_EQUAL(93u, descending_query.getDiversityCutoffGroups()); + EXPECT_EQ(-500, descending_query.getRangeLimit()); + EXPECT_EQ("ab56", descending_query.getDiversityAttribute()); + EXPECT_EQ(78u, descending_query.getMaxPerGroup()); + EXPECT_EQ(93u, descending_query.getDiversityCutoffGroups()); EXPECT_TRUE(descending_query.getDiversityCutoffStrict()); } -TEST("require that incorrectly specified diversity can be parsed") { +TEST(StreamingQueryTest, require_that_incorrectly_specified_diversity_can_be_parsed) +{ QueryNodeResultFactory eqnr; QueryTerm descending_query(eqnr.create(), "[;;-500;ab56]", "index", TermType::WORD); EXPECT_FALSE(descending_query.isValid()); } -TEST("require that we do not break the stack on bad query") { +TEST(StreamingQueryTest, require_that_we_do_not_break_the_stack_on_bad_query) +{ QueryTermSimple term("<form><iframe+	 +src=\\\"javascript:alert(1)\\\" 	;>", TermType::WORD); EXPECT_FALSE(term.isValid()); } -TEST("a unhandled sameElement stack") { +TEST(StreamingQueryTest, a_unhandled_sameElement_stack) +{ const char * stack = "\022\002\026xyz_abcdefghij_xyzxyzxQ\001\vxxxxxx_name\034xxxxxx_xxxx_xxxxxxx_xxxxxxxxE\002\005delta\b<0.00393"; vespalib::stringref stackDump(stack); - EXPECT_EQUAL(85u, stackDump.size()); + EXPECT_EQ(85u, stackDump.size()); AllowRewrite empty; const Query q(empty, stackDump); EXPECT_TRUE(q.valid()); const QueryNode & root = q.getRoot(); auto sameElement = dynamic_cast<const SameElementQueryNode *>(&root); EXPECT_TRUE(sameElement != nullptr); - EXPECT_EQUAL(2u, sameElement->size()); - EXPECT_EQUAL("xyz_abcdefghij_xyzxyzx", sameElement->getIndex()); + EXPECT_EQ(2u, sameElement->size()); + EXPECT_EQ("xyz_abcdefghij_xyzxyzx", sameElement->getIndex()); auto term0 = dynamic_cast<const QueryTerm *>((*sameElement)[0].get()); EXPECT_TRUE(term0 != nullptr); auto term1 = dynamic_cast<const QueryTerm *>((*sameElement)[1].get()); @@ -730,10 +754,12 @@ TEST("a unhandled sameElement stack") { namespace { void verifyQueryTermNode(const vespalib::string & index, const QueryNode *node) { EXPECT_TRUE(dynamic_cast<const QueryTerm *>(node) != nullptr); - EXPECT_EQUAL(index, node->getIndex()); + EXPECT_EQ(index, node->getIndex()); } } -TEST("testSameElementEvaluate") { + +TEST(StreamingQueryTest, test_same_element_evaluate) +{ QueryBuilder<SimpleQueryNodeTypes> builder; builder.addSameElement(3, "field", 0, Weight(0)); { @@ -747,15 +773,15 @@ TEST("testSameElementEvaluate") { Query q(empty, stackDump); SameElementQueryNode * sameElem = dynamic_cast<SameElementQueryNode *>(&q.getRoot()); EXPECT_TRUE(sameElem != nullptr); - EXPECT_EQUAL("field", sameElem->getIndex()); - EXPECT_EQUAL(3u, sameElem->size()); + EXPECT_EQ("field", sameElem->getIndex()); + EXPECT_EQ(3u, sameElem->size()); verifyQueryTermNode("field.f1", (*sameElem)[0].get()); verifyQueryTermNode("field.f2", (*sameElem)[1].get()); verifyQueryTermNode("field.f3", (*sameElem)[2].get()); QueryTermList terms; q.getLeaves(terms); - EXPECT_EQUAL(3u, terms.size()); + EXPECT_EQ(3u, terms.size()); for (QueryTerm * qt : terms) { qt->resizeFieldId(3); } @@ -782,30 +808,30 @@ TEST("testSameElementEvaluate") { terms[2]->add(17, 2, 6, 170); HitList hits; sameElem->evaluateHits(hits); - EXPECT_EQUAL(4u, hits.size()); - EXPECT_EQUAL(0u, hits[0].wordpos()); - EXPECT_EQUAL(2u, hits[0].context()); - EXPECT_EQUAL(0u, hits[0].elemId()); - EXPECT_EQUAL(130, hits[0].weight()); - - EXPECT_EQUAL(0u, hits[1].wordpos()); - EXPECT_EQUAL(2u, hits[1].context()); - EXPECT_EQUAL(2u, hits[1].elemId()); - EXPECT_EQUAL(140, hits[1].weight()); - - EXPECT_EQUAL(0u, hits[2].wordpos()); - EXPECT_EQUAL(2u, hits[2].context()); - EXPECT_EQUAL(4u, hits[2].elemId()); - EXPECT_EQUAL(150, hits[2].weight()); - - EXPECT_EQUAL(0u, hits[3].wordpos()); - EXPECT_EQUAL(2u, hits[3].context()); - EXPECT_EQUAL(5u, hits[3].elemId()); - EXPECT_EQUAL(160, hits[3].weight()); + EXPECT_EQ(4u, hits.size()); + EXPECT_EQ(0u, hits[0].wordpos()); + EXPECT_EQ(2u, hits[0].context()); + EXPECT_EQ(0u, hits[0].elemId()); + EXPECT_EQ(130, hits[0].weight()); + + EXPECT_EQ(0u, hits[1].wordpos()); + EXPECT_EQ(2u, hits[1].context()); + EXPECT_EQ(2u, hits[1].elemId()); + EXPECT_EQ(140, hits[1].weight()); + + EXPECT_EQ(0u, hits[2].wordpos()); + EXPECT_EQ(2u, hits[2].context()); + EXPECT_EQ(4u, hits[2].elemId()); + EXPECT_EQ(150, hits[2].weight()); + + EXPECT_EQ(0u, hits[3].wordpos()); + EXPECT_EQ(2u, hits[3].context()); + EXPECT_EQ(5u, hits[3].elemId()); + EXPECT_EQ(160, hits[3].weight()); EXPECT_TRUE(sameElem->evaluate()); } -TEST("test_nearest_neighbor_query_node") +TEST(StreamingQueryTest, test_nearest_neighbor_query_node) { QueryBuilder<SimpleQueryNodeTypes> builder; constexpr double distance_threshold = 35.5; @@ -824,27 +850,28 @@ TEST("test_nearest_neighbor_query_node") EXPECT_TRUE(qterm != nullptr); auto* node = dynamic_cast<NearestNeighborQueryNode *>(&q.getRoot()); EXPECT_TRUE(node != nullptr); - EXPECT_EQUAL(node, qterm->as_nearest_neighbor_query_node()); - EXPECT_EQUAL("qtensor", node->get_query_tensor_name()); - EXPECT_EQUAL("field", node->getIndex()); - EXPECT_EQUAL(id, static_cast<int32_t>(node->uniqueId())); - EXPECT_EQUAL(weight, node->weight().percent()); - EXPECT_EQUAL(distance_threshold, node->get_distance_threshold()); + EXPECT_EQ(node, qterm->as_nearest_neighbor_query_node()); + EXPECT_EQ("qtensor", node->get_query_tensor_name()); + EXPECT_EQ("field", node->getIndex()); + EXPECT_EQ(id, static_cast<int32_t>(node->uniqueId())); + EXPECT_EQ(weight, node->weight().percent()); + EXPECT_EQ(distance_threshold, node->get_distance_threshold()); EXPECT_FALSE(node->get_distance().has_value()); EXPECT_FALSE(node->evaluate()); node->set_distance(distance); EXPECT_TRUE(node->get_distance().has_value()); - EXPECT_EQUAL(distance, node->get_distance().value()); + EXPECT_EQ(distance, node->get_distance().value()); EXPECT_TRUE(node->evaluate()); node->reset(); EXPECT_FALSE(node->get_distance().has_value()); EXPECT_FALSE(node->evaluate()); } -TEST("Control the size of query terms") { - EXPECT_EQUAL(112u, sizeof(QueryTermSimple)); - EXPECT_EQUAL(128u, sizeof(QueryTermUCS4)); - EXPECT_EQUAL(272u, sizeof(QueryTerm)); +TEST(StreamingQueryTest, control_the_size_of_query_terms) +{ + EXPECT_EQ(112u, sizeof(QueryTermSimple)); + EXPECT_EQ(128u, sizeof(QueryTermUCS4)); + EXPECT_EQ(272u, sizeof(QueryTerm)); } -TEST_MAIN() { TEST_RUN_ALL(); } +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/vespamalloc/src/vespamalloc/malloc/allocchunk.cpp b/vespamalloc/src/vespamalloc/malloc/allocchunk.cpp index 818a10541ce..f519e768b72 100644 --- a/vespamalloc/src/vespamalloc/malloc/allocchunk.cpp +++ b/vespamalloc/src/vespamalloc/malloc/allocchunk.cpp @@ -3,26 +3,29 @@ namespace vespamalloc { - -void AFListBase::linkInList(AtomicHeadPtr & head, AFListBase * list) noexcept +void +AFListBase::linkInList(AtomicHeadPtr & head, AFListBase * list) noexcept { AFListBase * tail; for (tail = list; tail->_next != nullptr ;tail = tail->_next) { } linkIn(head, list, tail); } -void AFListBase::linkIn(AtomicHeadPtr & head, AFListBase * csl, AFListBase * tail) noexcept +void +AFListBase::linkIn(AtomicHeadPtr & head, AFListBase * csl, AFListBase * tail) noexcept { HeadPtr oldHead = head.load(std::memory_order_relaxed); HeadPtr newHead(csl, oldHead._tag + 1); tail->_next = static_cast<AFListBase *>(oldHead._ptr); + // linkIn/linkOut performs a release/acquire pair while ( __builtin_expect(! head.compare_exchange_weak(oldHead, newHead, std::memory_order_release, std::memory_order_relaxed), false) ) { - newHead._tag = oldHead._tag + 1; + newHead._tag = oldHead._tag + 1; tail->_next = static_cast<AFListBase *>(oldHead._ptr); } } -AFListBase * AFListBase::linkOut(AtomicHeadPtr & head) noexcept +AFListBase * +AFListBase::linkOut(AtomicHeadPtr & head) noexcept { HeadPtr oldHead = head.load(std::memory_order_relaxed); auto *csl = static_cast<AFListBase *>(oldHead._ptr); @@ -30,6 +33,7 @@ AFListBase * AFListBase::linkOut(AtomicHeadPtr & head) noexcept return nullptr; } HeadPtr newHead(csl->_next, oldHead._tag + 1); + // linkIn/linkOut performs a release/acquire pair while ( __builtin_expect(! head.compare_exchange_weak(oldHead, newHead, std::memory_order_acquire, std::memory_order_relaxed), false) ) { csl = static_cast<AFListBase *>(oldHead._ptr); if (csl == nullptr) { diff --git a/vespamalloc/src/vespamalloc/malloc/globalpool.h b/vespamalloc/src/vespamalloc/malloc/globalpool.h index fea8f8ffff8..97360e0d006 100644 --- a/vespamalloc/src/vespamalloc/malloc/globalpool.h +++ b/vespamalloc/src/vespamalloc/malloc/globalpool.h @@ -17,6 +17,8 @@ class AllocPoolT public: typedef AFList<MemBlockPtrT> ChunkSList; AllocPoolT(DataSegment & ds); + AllocPoolT(const AllocPoolT & ap) = delete; + AllocPoolT & operator = (const AllocPoolT & ap) = delete; ~AllocPoolT(); ChunkSList *getFree(SizeClassT sc, size_t minBlocks); @@ -40,8 +42,7 @@ private: ChunkSList * malloc(const Guard & guard, SizeClassT sc) __attribute__((noinline)); ChunkSList * getChunks(const Guard & guard, size_t numChunks) __attribute__((noinline)); ChunkSList * allocChunkList(const Guard & guard) __attribute__((noinline)); - AllocPoolT(const AllocPoolT & ap); - AllocPoolT & operator = (const AllocPoolT & ap); + void validate(const void * ptr) const noexcept; class AllocFree { diff --git a/vespamalloc/src/vespamalloc/malloc/globalpool.hpp b/vespamalloc/src/vespamalloc/malloc/globalpool.hpp index e68944f118d..2f7ff589492 100644 --- a/vespamalloc/src/vespamalloc/malloc/globalpool.hpp +++ b/vespamalloc/src/vespamalloc/malloc/globalpool.hpp @@ -87,6 +87,7 @@ typename AllocPoolT<MemBlockPtrT>::ChunkSList * AllocPoolT<MemBlockPtrT>::getFree(SizeClassT sc, size_t UNUSED(minBlocks)) { ChunkSList * csl = getFree(sc); + validate(csl); USE_STAT2(_stat[sc]._getFree.fetch_add(1, std::memory_order_relaxed)); return csl; } @@ -97,8 +98,10 @@ AllocPoolT<MemBlockPtrT>::exchangeFree(SizeClassT sc, typename AllocPoolT<MemBlo { PARANOID_CHECK1( if (csl->empty() || (csl->count() > ChunkSList::NumBlocks)) { *(int*)0 = 0; } ); AllocFree & af = _scList[sc]; + validate(af._full.load(std::memory_order_relaxed)._ptr); ChunkSList::linkIn(af._full, csl, csl); ChunkSList *ncsl = getFree(sc); + validate(ncsl); USE_STAT2(_stat[sc]._exchangeFree.fetch_add(1, std::memory_order_relaxed)); return ncsl; } @@ -109,14 +112,22 @@ AllocPoolT<MemBlockPtrT>::exchangeAlloc(SizeClassT sc, typename AllocPoolT<MemBl { PARANOID_CHECK1( if ( ! csl->empty()) { *(int*)0 = 0; } ); AllocFree & af = _scList[sc]; + validate(af._empty.load(std::memory_order_relaxed)._ptr); ChunkSList::linkIn(af._empty, csl, csl); ChunkSList * ncsl = getAlloc(sc); + validate(ncsl); USE_STAT2(_stat[sc]._exchangeAlloc.fetch_add(1, std::memory_order_relaxed)); PARANOID_CHECK1( if (ncsl->empty() || (ncsl->count() > ChunkSList::NumBlocks)) { *(int*)0 = 0; } ); return ncsl; } template <typename MemBlockPtrT> +void +AllocPoolT<MemBlockPtrT>::validate(const void * ptr) const noexcept { + assert((ptr == nullptr) || _dataSegment.containsPtr(ptr)); +} + +template <typename MemBlockPtrT> typename AllocPoolT<MemBlockPtrT>::ChunkSList * AllocPoolT<MemBlockPtrT>::exactAlloc(size_t exactSize, SizeClassT sc, typename AllocPoolT<MemBlockPtrT>::ChunkSList * csl) |