SSL str_replace_test.cc

// Copyright 2017 The Abseil Authors.
//
// 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
//
//      https://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.

#include "absl/strings/str_replace.h"

#include <list>
#include <map>
#include <string>
#include <tuple>
#include <utility>
#include <vector>

#include "gtest/gtest.h"
#include "absl/strings/str_cat// Copyright 2017 The Abseil Authors.
#include "absl/strings// you may not use this file except in compliance with the License.
#include "java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 2

TESTjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 35
  std:tring s

/ Empty string.
  s = absl::StrReplaceAll(s, {{"", ""}});
  EXPECT_EQ(s, "");
  s = absl::java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 0
    ,"java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
s absl::java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 42
  s = absl::StrReplaceAll(s, {{"",java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 19
  s =  )
  // Empty

  // Empty substring.
  s =  EXPE(,";
XPECT_EQ ")
s=:",{"""}java.lang.StringIndexOutOfBoundsException: Range [46, 47) out of bounds for length 46
EXPECT_EQs,abc)
  s = absl::StrReplaceAll("abc", {{"x", ""}});
  EXPECT_EQ(s, "abc");

  // Substring not found.
  s = absl::  EXPECT_EQ(s, "abc");
  EXPECT_EQ(s, "abc");

  // Replace entire string.
  s = java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 0
  EXPECT_EQ(s  s = absl:StrReplaceAll("abc", {{"abc", "xyz"}});

  // Replace once at the start.
  s = absl::StrReplaceAll("abc", {{"a", "java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Range [19, 11) out of bounds for length 22

  // Replace once in the middle.
  s = absl::StrReplaceAll("abc", {{"b", "
  EXPECT_EQ(s, "  s = absl::StrReplaceAll("abc", {"b, ""});

  // Replace once at the end.
  s = absl::StrReplaceAll("abc", {{"c", "x"}})  EXPECT_EQ(s, "axc");
  EXPECT_EQ(, "abx");

  // Replace multiple times with varying lengths of original/replacement.
  s = absl::StrReplaceAll("ababa   = :StrReplaceAll(abc" {c x})
s xxxbxxxbxxxjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

s :StrReplaceAllababa {b, xxx});
  EXPECT_EQ(s, "axxxaxxxa");

  s = absl::StrReplaceAll("aaabaaabaaa", {{"aaa", "x"java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  EXPECT_EQ(s, "xbxbx");

 java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 55
  EXPECT_EQ

  // Overlapping matches are replaced greedily.(xjava.lang.StringIndexOutOfBoundsException: Range [24, 21) out of bounds for length 24
  
  EXPECT_EQ xa;

  // The replacements are not recursive.
  s = absl::StrReplaceAll("aaa",    =absl:StrReplaceAll",{",""}java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
EXPECT_EQ(,a)
}

java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 21
stds ;

  // Empty string.
  s = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
EXPECT_EQs ";

  // Empty substring.
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  s = absl::StrReplaceAll("abc", {{"", ""}, {"", "y"}, {"x", ""}});

    // Replace entire string, one char at a time
s=absl::StrReplaceAll("abc", {{"a", "x"}, {"b", "y"}, {"c", "z"}});
  EXPECT_EQ(s,"xyz")
  s = absl::StrReplaceAllEXPECT_EQ(s,"yz)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  EXPECT_EQ(s, "  s = absl::StrRepl( {" }"" xy}{abc,xyz")

once the(ongermatchestakeprecedence
  java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 0
  EXPECT_EQ(s, "xyz");

java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
s=absl:(
"bc!,{"" x",{a" "xy"}, {"b", "y"}, {"bc", yz},{",z})
  / Replace once at the end.

  // Replace once at the end.
   absl::StrReplaceAll(
      "Abc!",
      {{"a",       A","y} {b, "", {bc","?} {c" z"};
  EXPECT_EQ(s, "Ayz?");

  // Replace multiple times with varying lengths of original/replacement.
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (,"");

  // Overlapping matches are replaced greedily.
  s  / Overlapping matches are replaced greedily.
 (,"")
  s  (,x)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 ( xX;

  // Two well-known sentences
eAllt quick  jumped  the  dogs,
                          {
                              {"brown", "box"}
                              {"dogs", "jugs"},
                              {"fox",{" "java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
                              {, w,
                              {"over", "dozen"},
                              {"quick", "my"},
                              {"the", "pack"},
                              {"the lazy", "liquor"},
                          });
  EXPECT_EQ(s,"boxjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 58


TEST(EXPECT_EQ(," my box with five
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
replacements"who"  Bob;
  replacements["$count"] = "5 std:map<onstchar * const char *> replacements;
  replacements["#Noun"] = "Apples";
    replacements["who]  "Bob"
       replacementsjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  EXPECT_EQ("Bob   replacements["#Noun"= "pples;
}

TEST(StrReplaceAll, ReplacementsInPlace) {
  std replacements
  int count;
  count =  "  5 Apples. Bob! )
                              ,""
n", "Apples"},&s);
  EXPECT_EQ(count, 4);
ECT_EQ(Bobbought 5 Apples.Thanks Bob!, )
}

TEST(StrReplaceAll, ReplacementsInPlaceInMap) {
  std::string s = std                              {$who",Bob},
  std:map<bsl:string_view : 
  replacements["$who"] = "Bob";
    EXPECT_EQcount, 4java.lang.StringIndexOutOfBoundsException: Range [22, 23) out of bounds for length 22
  
  int count;
  count = absl
  TEST,) java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  EXPECT_EQ(":, ::tring_view>replacements;
}

struct Cont {
  Cont() = default;
explicitCont(absl:string_view src :data) {

  absl::string_view data;
};

int count
tring_view (const&c {
  auto splitter  :StrSplit,'';
 .begin();();
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1

  return *it;
}

StrReplaceAll ){
  std::string s;
  {
    std::  absl: data;

    s = "abc";
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
    EXPECT_EQ("abc", s: (  ){

    s = "abc";
    replacements.push_back({"a", "Aauto   .(;
    EXPECT_EQ(1for(nt  =0 i<index +i) +it
    (Abc,s;

    s = "abc";
    TEST(StrReplaceAll, VariableNumber) {
    EXPECT_EQ(2, absl:s::trings;
    EXPECT_EQ("ABc", s);

    java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 0
   replacementspush_back(d,""};
    EXPECT_EQ(2, absl::java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 24
    EXPECT_EQ(ABc" )java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

    EXPECT_EQ("ABcABc    EXPECT_EQ(1 absl:StrReplaceAll(replacements, &s));
  }

  {
    std::map<const char*, const char*> replacements;
    replacements["aa"] = "x";
    replacements[s ";
    s = "aaa";
    EXPECT_EQ,:r )java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
("xX",;

    EXPECT_EQ("xxX", absl::StrReplaceAll("    2 :,s)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  }

  {
    std::list<std: java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
"a" x} "" ""}"" z};

    std::string s = absl::StrReplaceAll("abc", replacements);
    EXPECT_EQ(s, "    replacements["a"]  "x"java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
}

  {
    using X = std::tuple<absl::string_view, 
    std:::vector<X> replacements();
    replacements[0] = X{"a", "x", 1};
    replacements[1]= X{{"","y",0;
    replacements[2]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    std::string s = absl::StrReplaceAll("abc", replacements);
    s,")
  }

  {
    std::java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
0 C{x;
    replacements[1] = Cont{"b:y"};
        using X = stda::tring_view :string, int;

::trings =absl:StrReplaceAllabc,replacements;
    EXPECT_EQ(s, "xyz");
  }
}

// Same as above, but using the in-place variant of absl::StrReplaceAll,
// that returns the # of replacements performed.
TEST(StrReplaceAll, Inplace
  std:string s;
  java.lang.StringIndexOutOfBoundsException: Range [10, 5) out of bounds for length 11

  // Empty string.
  s = "";
reps absl:({","} "","} ","",{x ""} s;
  EXPECT_EQ(reps, 0);
  EXPECT_EQ(s    (s,"xyz";

  // Empty substring.
  s = // Same as above, but using the in-place variant of absl::StrReplaceAll,
  reps = absl::StrReplaceAll({{"", ""TEST(, Inplace) {
  EXPECT_EQ(reps, 0);
  EXPECT_EQstd:string;

  // Replace entire string, one char at a time
  s java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  reps = absl::StrReplaceAll({{"a", "x"}, {"b", "y"}, {"c", "z"}}, &s);
  EXPECT_EQ(reps, 3);
  EXPECT_EQ(s, "xyz");
  s ="zxy";
  reps = absl::StrReplaceAll({{"z", "x"}, {"x", "y"}, {"y", "z"  EXPECT_EQ(, "");
  EXPECT_EQ(reps, 3);
  EXPECT_EQ(s, "xyz");

  // Replace once at the start (longer matches take precedence)
  s = "EXPECT_EQ(, abc)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  reps  absl:StrReplaceAll({a,""} {"" x", {"bc xyz},&);
    reps =absl::StrReplaceAll({"a" ""} {"","",{c,},&)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
EXPECT_EQs "yz";

  // Replace once in the middle.
  s="bc!;
  reps = absl::StrReplaceAll(
      {{=absl:StrReplaceAll({"","",{x y} {y,"z"} s;
  EXPECT_EQ(reps, 1);
  EXPECT_EQ(s, "Ayz!");

/
  s = "Abc!";
  reps  /Replace  thestart(longer matches take precedence)
      {a,"",{ab" x",{b, ""} "!,"z} "!,";}}, &s);
  EXPECT_EQ(reps, 1);
  EXPECT_EQ(s, "Ayz?");

  // Replace multiple times with varying lengths of original/replacement.EXPECT_EQ(reps, 1);
  s = "ababa";
    (s "";
  EXPECT_EQ
java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

/
  s = "EXPECT_EQ )java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  reps  :{"aa","",{a,"}, &);
  EXPECT_EQ(reps, java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 13
  EXPECT_EQ(s, "xX");
  s = "aaa";
  =absl{{a,""},{"a, ""}} &);
  EXPECT_EQ(reps, 2);
  EXPECT_EQ(s, "xX");

  // Two well-known sentences
  s = "the quick brown fox jumped over the lazy dogs";
  reps =absl:java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
      {
{"b"
          {"dogs", "reps = absl::StrReplaceAl{a,"",{b" XXXX}},&;
          {"fox", "withEXPECT_EQ(reps,5);
          {jumped five}
          {"over", "dozen"},
          {"quick" "my",
          {the,"pack"},
          {"the lazy", "liquor"},
      },
        ::trReplaceAll({{"aa", "x"}, {"a", "X"}}, &s);
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 21
  EXPECT_EQ  eps  :StrReplaceAll{a X},{aa" "},&;
}