/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include <stdio.h>

#include <stdlib.h>

#include "nsASCIIMask.h"

#include "nsString.h"

#include "nsStringBuffer.h"

#include "nsReadableUtils.h"

#include "nsCRTGlue.h"

#include "mozilla/RefPtr.h"

#include "mozilla/Unused.h"

#include "nsTArray.h"

#include "gtest/gtest.h"

#include "gtest/MozGTestBench.h" // For MOZ_GTEST_BENCH

#include "gtest/BlackBox.h"

#include "nsBidiUtils.h"

#define CONVERSION_ITERATIONS 50000

#define CONVERSION_BENCH(name, func, src, dstType) \

MOZ_GTEST_BENCH_F(Strings, name, [this] { \

    for (int i = 0; i < CONVERSION_ITERATIONS; i++) { \

      dstType dst; \

      func(*BlackBox(&src), *BlackBox(&dst)); \

    } \

}); \

namespace TestStrings {

using mozilla::fallible;

using mozilla::BlackBox;

#define TestExample1 "Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium,\n totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi\r architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur\n aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam est, qui\r\n\r dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?"

#define TestExample2 "At vero eos et accusamus et iusto odio dignissimos ducimus\n\n qui blanditiis praesentium voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi sint occaecati cupiditate non provident, similique sunt in culpa qui officia deserunt\r\r  \n mollitia animi, id est laborum et dolorum fuga. Et harum quidem rerum facilis est et expedita distinctio. Nam libero tempore, cum soluta nobis est eligendi optio cumque nihil impedit quo minus id quod maxime placeat facere possimus, omnis voluptas assumenda       est, omnis dolor repellendus. Temporibus autem quibusdam et aut officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae. Itaque earum rerum hic tenetur a sapiente delectus, ut aut reiciendis voluptatibus maiores alias consequatur aut perferendis doloribus asperiores repellat."

#define TestExample3 " Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis ac tellus eget velit viverra viverra id sit amet neque. Sed id consectetur mi, vestibulum aliquet arcu. Curabitur sagittis accumsan convallis. Sed eu condimentum ipsum, a laoreet tortor. Orci varius natoque penatibus et magnis dis    \r\r\n\n parturient montes, nascetur ridiculus mus. Sed non tellus nec ante sodales placerat a nec risus. Cras vel bibendum sapien, nec ullamcorper felis. Pellentesque congue eget nisi sit amet vehicula. Morbi pulvinar turpis justo, in commodo dolor vulputate id. Curabitur in dui urna. Vestibulum placerat dui in sem congue, ut faucibus nibh rutrum. Duis mattis turpis facilisis ullamcorper tincidunt. Vestibulum pharetra tortor at enim sagittis, dapibus consectetur ex blandit. Curabitur ac fringilla quam. In ornare lectus ut ipsum mattis venenatis. Etiam in mollis lectus, sed luctus risus.\nCras dapibus\f\t  \n finibus justo sit amet dictum. Aliquam non elit diam. Fusce magna nulla, bibendum in massa a, commodo finibus lectus. Sed rutrum a augue id imperdiet. Aliquam sagittis sodales felis, a tristique ligula. Aliquam erat volutpat. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Duis volutpat interdum lorem et congue. Phasellus porttitor posuere justo eget euismod. Nam a condimentum turpis, sit amet gravida lacus. Vestibulum dolor diam, lobortis ac metus et, convallis dapibus tellus. Ut nec metus in velit malesuada tincidunt et eget justo. Curabitur ut libero bibendum, porttitor diam vitae, aliquet justo. "

#define TestExample4 " Donec feugiat volutpat massa. Cras ornare lacinia porta. Fusce in feugiat nunc. Praesent non felis varius diam feugiat ultrices ultricies a risus. Donec maximus nisi nisl, non consectetur nulla eleifend in. Nulla in massa interdum, eleifend orci a, vestibulum est. Mauris aliquet, massa et convallis mollis, felis augue vestibulum augue, in lobortis metus eros a quam. Nam              ac diam ornare, vestibulum elit sit amet, consectetur ante. Praesent massa mauris, pulvinar sit amet sapien vel, tempus gravida neque. Praesent id quam sit amet est maximus molestie eget at turpis. Nunc sit amet orci id arcu dapibus fermentum non eu erat.\f\tSuspendisse commodo nunc sem, eu congue eros condimentum vel. Nullam sit amet posuere arcu. Nulla facilisi. Mauris dapibus iaculis massa sed gravida. Nullam vitae urna at tortor feugiat auctor ut sit amet dolor. Proin rutrum at nunc et faucibus. Quisque suscipit id nibh a aliquet. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Aliquam a dapibus erat, id imperdiet mauris. Nulla blandit libero non magna dapibus tristique. Integer hendrerit imperdiet lorem, quis facilisis lacus semper ut. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae Nullam dignissim elit in congue ultricies. Quisque erat odio, maximus mollis laoreet id, iaculis at turpis. "

#define TestExample5 "Donec id risus urna. Nunc consequat lacinia urna id bibendum. Nulla faucibus faucibus enim. Cras ex risus, ultrices id semper vitae, luctus ut nulla. Sed vehicula tellus sed purus imperdiet efficitur. Suspendisse feugiat\n\n\n     imperdiet odio, sed porta lorem feugiat nec. Curabitur laoreet massa venenatis\r\n risus ornare\r\n, vitae feugiat tortor accumsan. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas id scelerisque mauris, eget facilisis erat. Ut nec pulvinar risus, sed iaculis ante. Mauris tincidunt, risus et pretium elementum, leo nisi consectetur ligula, tincidunt suscipit erat velit eget libero. Sed ac est tempus, consequat dolor mattis, mattis mi. "

// Originally ReadVPXFile in TestVPXDecoding.cpp

static void

ReadFile(const char* aPath, nsACString& aBuffer)

{

  FILE* f = fopen(aPath, "rb");

  ASSERT_NE(f, (FILE *) nullptr);

  int r = fseek(f, 0, SEEK_END);

  ASSERT_EQ(r, 0);

  long size = ftell(f);

  ASSERT_NE(size, -1);

  aBuffer.SetLength(size);

  r = fseek(f, 0, SEEK_SET);

  ASSERT_EQ(r, 0);

  size_t got = fread(aBuffer.BeginWriting(), 1, size, f);

  ASSERT_EQ(got, size_t(size));

  r = fclose(f);

  ASSERT_EQ(r, 0);

}

class Strings : public ::testing::Test {

protected:

  void SetUp() override {

    // Intentionally AssignASCII and not AssignLiteral

    // to simulate the usual heap case.

    mExample1Utf8.AssignASCII(TestExample1);

    mExample2Utf8.AssignASCII(TestExample2);

    mExample3Utf8.AssignASCII(TestExample3);

    mExample4Utf8.AssignASCII(TestExample4);

    mExample5Utf8.AssignASCII(TestExample5);

    // Use span to make the resulting string as ordinary as possible

    mAsciiOneUtf8.Append(MakeSpan(mExample3Utf8).To(1));

    mAsciiThreeUtf8.Append(MakeSpan(mExample3Utf8).To(3));

    mAsciiFifteenUtf8.Append(MakeSpan(mExample3Utf8).To(15));

    mAsciiHundredUtf8.Append(MakeSpan(mExample3Utf8).To(100));

    mAsciiThousandUtf8.Append(MakeSpan(mExample3Utf8).To(1000));

    ReadFile("ar.txt", mArUtf8);

    ReadFile("de.txt", mDeUtf8);

    ReadFile("de-edit.txt", mDeEditUtf8);

    ReadFile("ru.txt", mRuUtf8);

    ReadFile("th.txt", mThUtf8);

    ReadFile("ko.txt", mKoUtf8);

    ReadFile("ja.txt", mJaUtf8);

    ReadFile("tr.txt", mTrUtf8);

    ReadFile("vi.txt", mViUtf8);

    CopyASCIItoUTF16(mExample1Utf8, mExample1Utf16);

    CopyASCIItoUTF16(mExample2Utf8, mExample2Utf16);

    CopyASCIItoUTF16(mExample3Utf8, mExample3Utf16);

    CopyASCIItoUTF16(mExample4Utf8, mExample4Utf16);

    CopyASCIItoUTF16(mExample5Utf8, mExample5Utf16);

    CopyASCIItoUTF16(mAsciiOneUtf8, mAsciiOneUtf16);

    CopyASCIItoUTF16(mAsciiFifteenUtf8, mAsciiFifteenUtf16);

    CopyASCIItoUTF16(mAsciiHundredUtf8, mAsciiHundredUtf16);

    CopyASCIItoUTF16(mAsciiThousandUtf8, mAsciiThousandUtf16);

    CopyUTF8toUTF16(mArUtf8, mArUtf16);

    CopyUTF8toUTF16(mDeUtf8, mDeUtf16);

    CopyUTF8toUTF16(mDeEditUtf8, mDeEditUtf16);

    CopyUTF8toUTF16(mRuUtf8, mRuUtf16);

    CopyUTF8toUTF16(mThUtf8, mThUtf16);

    CopyUTF8toUTF16(mJaUtf8, mJaUtf16);

    CopyUTF8toUTF16(mKoUtf8, mKoUtf16);

    CopyUTF8toUTF16(mTrUtf8, mTrUtf16);

    CopyUTF8toUTF16(mViUtf8, mViUtf16);

    LossyCopyUTF16toASCII(mDeEditUtf16, mDeEditLatin1);

    // Use span to make the resulting string as ordinary as possible

    mArOneUtf16.Append(MakeSpan(mArUtf16).To(1));

    mDeOneUtf16.Append(MakeSpan(mDeUtf16).To(1));

    mDeEditOneUtf16.Append(MakeSpan(mDeEditUtf16).To(1));

    mRuOneUtf16.Append(MakeSpan(mRuUtf16).To(1));

    mThOneUtf16.Append(MakeSpan(mThUtf16).To(1));

    mJaOneUtf16.Append(MakeSpan(mJaUtf16).To(1));

    mKoOneUtf16.Append(MakeSpan(mKoUtf16).To(1));

    mTrOneUtf16.Append(MakeSpan(mTrUtf16).To(1));

    mViOneUtf16.Append(MakeSpan(mViUtf16).To(1));

    mDeEditOneLatin1.Append(MakeSpan(mDeEditLatin1).To(1));

    mArThreeUtf16.Append(MakeSpan(mArUtf16).To(3));

    mDeThreeUtf16.Append(MakeSpan(mDeUtf16).To(3));

    mDeEditThreeUtf16.Append(MakeSpan(mDeEditUtf16).To(3));

    mRuThreeUtf16.Append(MakeSpan(mRuUtf16).To(3));

    mThThreeUtf16.Append(MakeSpan(mThUtf16).To(3));

    mJaThreeUtf16.Append(MakeSpan(mJaUtf16).To(3));

    mKoThreeUtf16.Append(MakeSpan(mKoUtf16).To(3));

    mTrThreeUtf16.Append(MakeSpan(mTrUtf16).To(3));

    mViThreeUtf16.Append(MakeSpan(mViUtf16).To(3));

    mDeEditThreeLatin1.Append(MakeSpan(mDeEditLatin1).To(3));

    mArFifteenUtf16.Append(MakeSpan(mArUtf16).To(15));

    mDeFifteenUtf16.Append(MakeSpan(mDeUtf16).To(15));

    mDeEditFifteenUtf16.Append(MakeSpan(mDeEditUtf16).To(15));

    mRuFifteenUtf16.Append(MakeSpan(mRuUtf16).To(15));

    mThFifteenUtf16.Append(MakeSpan(mThUtf16).To(15));

    mJaFifteenUtf16.Append(MakeSpan(mJaUtf16).To(15));

    mKoFifteenUtf16.Append(MakeSpan(mKoUtf16).To(15));

    mTrFifteenUtf16.Append(MakeSpan(mTrUtf16).To(15));

    mViFifteenUtf16.Append(MakeSpan(mViUtf16).To(15));

    mDeEditFifteenLatin1.Append(MakeSpan(mDeEditLatin1).To(15));

    mArHundredUtf16.Append(MakeSpan(mArUtf16).To(100));

    mDeHundredUtf16.Append(MakeSpan(mDeUtf16).To(100));

    mDeEditHundredUtf16.Append(MakeSpan(mDeEditUtf16).To(100));

    mRuHundredUtf16.Append(MakeSpan(mRuUtf16).To(100));

    mThHundredUtf16.Append(MakeSpan(mThUtf16).To(100));

    mJaHundredUtf16.Append(MakeSpan(mJaUtf16).To(100));

    mKoHundredUtf16.Append(MakeSpan(mKoUtf16).To(100));

    mTrHundredUtf16.Append(MakeSpan(mTrUtf16).To(100));

    mViHundredUtf16.Append(MakeSpan(mViUtf16).To(100));

    mDeEditHundredLatin1.Append(MakeSpan(mDeEditLatin1).To(100));

    mArThousandUtf16.Append(MakeSpan(mArUtf16).To(1000));

    mDeThousandUtf16.Append(MakeSpan(mDeUtf16).To(1000));

    mDeEditThousandUtf16.Append(MakeSpan(mDeEditUtf16).To(1000));

    mRuThousandUtf16.Append(MakeSpan(mRuUtf16).To(1000));

    mThThousandUtf16.Append(MakeSpan(mThUtf16).To(1000));

    mJaThousandUtf16.Append(MakeSpan(mJaUtf16).To(1000));

    mKoThousandUtf16.Append(MakeSpan(mKoUtf16).To(1000));

    mTrThousandUtf16.Append(MakeSpan(mTrUtf16).To(1000));

    mViThousandUtf16.Append(MakeSpan(mViUtf16).To(1000));

    mDeEditThousandLatin1.Append(MakeSpan(mDeEditLatin1).To(1000));

    CopyUTF16toUTF8(mArOneUtf16, mArOneUtf8);

    CopyUTF16toUTF8(mDeOneUtf16, mDeOneUtf8);

    CopyUTF16toUTF8(mDeEditOneUtf16, mDeEditOneUtf8);

    CopyUTF16toUTF8(mRuOneUtf16, mRuOneUtf8);

    CopyUTF16toUTF8(mThOneUtf16, mThOneUtf8);

    CopyUTF16toUTF8(mJaOneUtf16, mJaOneUtf8);

    CopyUTF16toUTF8(mKoOneUtf16, mKoOneUtf8);

    CopyUTF16toUTF8(mTrOneUtf16, mTrOneUtf8);

    CopyUTF16toUTF8(mViOneUtf16, mViOneUtf8);

    CopyUTF16toUTF8(mArThreeUtf16, mArThreeUtf8);

    CopyUTF16toUTF8(mDeThreeUtf16, mDeThreeUtf8);

    CopyUTF16toUTF8(mDeEditThreeUtf16, mDeEditThreeUtf8);

    CopyUTF16toUTF8(mRuThreeUtf16, mRuThreeUtf8);

    CopyUTF16toUTF8(mThThreeUtf16, mThThreeUtf8);

    CopyUTF16toUTF8(mJaThreeUtf16, mJaThreeUtf8);

    CopyUTF16toUTF8(mKoThreeUtf16, mKoThreeUtf8);

    CopyUTF16toUTF8(mTrThreeUtf16, mTrThreeUtf8);

    CopyUTF16toUTF8(mViThreeUtf16, mViThreeUtf8);

    CopyUTF16toUTF8(mArFifteenUtf16, mArFifteenUtf8);

    CopyUTF16toUTF8(mDeFifteenUtf16, mDeFifteenUtf8);

    CopyUTF16toUTF8(mDeEditFifteenUtf16, mDeEditFifteenUtf8);

    CopyUTF16toUTF8(mRuFifteenUtf16, mRuFifteenUtf8);

    CopyUTF16toUTF8(mThFifteenUtf16, mThFifteenUtf8);

    CopyUTF16toUTF8(mJaFifteenUtf16, mJaFifteenUtf8);

    CopyUTF16toUTF8(mKoFifteenUtf16, mKoFifteenUtf8);

    CopyUTF16toUTF8(mTrFifteenUtf16, mTrFifteenUtf8);

    CopyUTF16toUTF8(mViFifteenUtf16, mViFifteenUtf8);

    CopyUTF16toUTF8(mArHundredUtf16, mArHundredUtf8);

    CopyUTF16toUTF8(mDeHundredUtf16, mDeHundredUtf8);

    CopyUTF16toUTF8(mDeEditHundredUtf16, mDeEditHundredUtf8);

    CopyUTF16toUTF8(mRuHundredUtf16, mRuHundredUtf8);

    CopyUTF16toUTF8(mThHundredUtf16, mThHundredUtf8);

    CopyUTF16toUTF8(mJaHundredUtf16, mJaHundredUtf8);

    CopyUTF16toUTF8(mKoHundredUtf16, mKoHundredUtf8);

    CopyUTF16toUTF8(mTrHundredUtf16, mTrHundredUtf8);

    CopyUTF16toUTF8(mViHundredUtf16, mViHundredUtf8);

    CopyUTF16toUTF8(mArThousandUtf16, mArThousandUtf8);

    CopyUTF16toUTF8(mDeThousandUtf16, mDeThousandUtf8);

    CopyUTF16toUTF8(mDeEditThousandUtf16, mDeEditThousandUtf8);

    CopyUTF16toUTF8(mRuThousandUtf16, mRuThousandUtf8);

    CopyUTF16toUTF8(mThThousandUtf16, mThThousandUtf8);

    CopyUTF16toUTF8(mJaThousandUtf16, mJaThousandUtf8);

    CopyUTF16toUTF8(mKoThousandUtf16, mKoThousandUtf8);

    CopyUTF16toUTF8(mTrThousandUtf16, mTrThousandUtf8);

    CopyUTF16toUTF8(mViThousandUtf16, mViThousandUtf8);

  }

public:

  nsCString mAsciiOneUtf8;

  nsCString mAsciiThreeUtf8;

  nsCString mAsciiFifteenUtf8;

  nsCString mAsciiHundredUtf8;

  nsCString mAsciiThousandUtf8;

  nsCString mExample1Utf8;

  nsCString mExample2Utf8;

  nsCString mExample3Utf8;

  nsCString mExample4Utf8;

  nsCString mExample5Utf8;

  nsCString mArUtf8;

  nsCString mDeUtf8;

  nsCString mDeEditUtf8;

  nsCString mRuUtf8;

  nsCString mThUtf8;

  nsCString mJaUtf8;

  nsCString mKoUtf8;

  nsCString mTrUtf8;

  nsCString mViUtf8;

  nsString mAsciiOneUtf16;

  nsString mAsciiThreeUtf16;

  nsString mAsciiFifteenUtf16;

  nsString mAsciiHundredUtf16;

  nsString mAsciiThousandUtf16;

  nsString mExample1Utf16;

  nsString mExample2Utf16;

  nsString mExample3Utf16;

  nsString mExample4Utf16;

  nsString mExample5Utf16;

  nsString mArUtf16;

  nsString mDeUtf16;

  nsString mDeEditUtf16;

  nsString mRuUtf16;

  nsString mThUtf16;

  nsString mJaUtf16;

  nsString mKoUtf16;

  nsString mTrUtf16;

  nsString mViUtf16;

  nsCString mDeEditLatin1;

  nsString mArOneUtf16;

  nsString mDeOneUtf16;

  nsString mDeEditOneUtf16;

  nsString mRuOneUtf16;

  nsString mThOneUtf16;

  nsString mJaOneUtf16;

  nsString mKoOneUtf16;

  nsString mTrOneUtf16;

  nsString mViOneUtf16;

  nsCString mDeEditOneLatin1;

  nsCString mArOneUtf8;

  nsCString mDeOneUtf8;

  nsCString mDeEditOneUtf8;

  nsCString mRuOneUtf8;

  nsCString mThOneUtf8;

  nsCString mJaOneUtf8;

  nsCString mKoOneUtf8;

  nsCString mTrOneUtf8;

  nsCString mViOneUtf8;

  nsString mArThreeUtf16;

  nsString mDeThreeUtf16;

  nsString mDeEditThreeUtf16;

  nsString mRuThreeUtf16;

  nsString mThThreeUtf16;

  nsString mJaThreeUtf16;

  nsString mKoThreeUtf16;

  nsString mTrThreeUtf16;

  nsString mViThreeUtf16;

  nsCString mDeEditThreeLatin1;

  nsCString mArThreeUtf8;

  nsCString mDeThreeUtf8;

  nsCString mDeEditThreeUtf8;

  nsCString mRuThreeUtf8;

  nsCString mThThreeUtf8;

  nsCString mJaThreeUtf8;

  nsCString mKoThreeUtf8;

  nsCString mTrThreeUtf8;

  nsCString mViThreeUtf8;

  nsString mArFifteenUtf16;

  nsString mDeFifteenUtf16;

  nsString mDeEditFifteenUtf16;

  nsString mRuFifteenUtf16;

  nsString mThFifteenUtf16;

  nsString mJaFifteenUtf16;

  nsString mKoFifteenUtf16;

  nsString mTrFifteenUtf16;

  nsString mViFifteenUtf16;

  nsCString mDeEditFifteenLatin1;

  nsCString mArFifteenUtf8;

  nsCString mDeFifteenUtf8;

  nsCString mDeEditFifteenUtf8;

  nsCString mRuFifteenUtf8;

  nsCString mThFifteenUtf8;

  nsCString mJaFifteenUtf8;

  nsCString mKoFifteenUtf8;

  nsCString mTrFifteenUtf8;

  nsCString mViFifteenUtf8;

  nsString mArHundredUtf16;

  nsString mDeHundredUtf16;

  nsString mDeEditHundredUtf16;

  nsString mRuHundredUtf16;

  nsString mThHundredUtf16;

  nsString mJaHundredUtf16;

  nsString mKoHundredUtf16;

  nsString mTrHundredUtf16;

  nsString mViHundredUtf16;

  nsCString mDeEditHundredLatin1;

  nsCString mArHundredUtf8;

  nsCString mDeHundredUtf8;

  nsCString mDeEditHundredUtf8;

  nsCString mRuHundredUtf8;

  nsCString mThHundredUtf8;

  nsCString mJaHundredUtf8;

  nsCString mKoHundredUtf8;

  nsCString mTrHundredUtf8;

  nsCString mViHundredUtf8;

  nsString mArThousandUtf16;

  nsString mDeThousandUtf16;

  nsString mDeEditThousandUtf16;

  nsString mRuThousandUtf16;

  nsString mThThousandUtf16;

  nsString mJaThousandUtf16;

  nsString mKoThousandUtf16;

  nsString mTrThousandUtf16;

  nsString mViThousandUtf16;

  nsCString mDeEditThousandLatin1;

  nsCString mArThousandUtf8;

  nsCString mDeThousandUtf8;

  nsCString mDeEditThousandUtf8;

  nsCString mRuThousandUtf8;

  nsCString mThThousandUtf8;

  nsCString mJaThousandUtf8;

  nsCString mKoThousandUtf8;

  nsCString mTrThousandUtf8;

  nsCString mViThousandUtf8;

};

void test_assign_helper(const nsACString& in, nsACString &_retval)

{

  _retval = in;

}

// Simple helper struct to test if conditionally enabled string functions are

// working.

template <typename T>

struct EnableTest

{

  template <typename Q = T, typename EnableIfChar16 = mozilla::Char16OnlyT<Q>>

  bool IsChar16() { return true; }

  template <typename Q = T, typename EnableIfChar = mozilla::CharOnlyT<Q>>

  bool IsChar16(int dummy = 42) { return false; }

  template <typename Q = T, typename EnableIfChar16 = mozilla::Char16OnlyT<Q>>

  bool IsChar() { return false; }

  template <typename Q = T, typename EnableIfChar = mozilla::CharOnlyT<Q>>

  bool IsChar(int dummy = 42) { return true; }

};

TEST_F(Strings, IsChar)

{

  EnableTest<char> charTest;

  EXPECT_TRUE(charTest.IsChar());

  EXPECT_FALSE(charTest.IsChar16());

  EnableTest<char16_t> char16Test;

  EXPECT_TRUE(char16Test.IsChar16());

  EXPECT_FALSE(char16Test.IsChar());

#ifdef COMPILATION_FAILURE_TEST

  nsAutoCString a_ctest;

  nsAutoString a_test;

  a_ctest.AssignLiteral("hello");

  // This should cause a compilation failure.

  a_ctest.AssignLiteral(u"hello");

  a_test.AssignLiteral(u"hello");

  a_test.AssignLiteral("hello");

#endif

}

TEST_F(Strings, DependentStrings)

{

  // A few tests that make sure copying nsTDependentStrings behaves properly.

  using DataFlags = mozilla::detail::StringDataFlags;

  {

    // Test copy ctor.

    nsDependentCString tmp("foo");

    auto data = tmp.Data();

    nsDependentCString foo(tmp);

    // Neither string should be using a shared buffer.

    EXPECT_FALSE(tmp.GetDataFlags() & DataFlags::REFCOUNTED);

    EXPECT_FALSE(foo.GetDataFlags() & DataFlags::REFCOUNTED);

    // Both strings should be pointing to the original buffer.

    EXPECT_EQ(data, tmp.Data());

    EXPECT_EQ(data, foo.Data());

  }

  {

    // Test move ctor.

    nsDependentCString tmp("foo");

    auto data = tmp.Data();

    nsDependentCString foo(std::move(tmp));

    // Neither string should be using a shared buffer.

    EXPECT_FALSE(tmp.GetDataFlags() & DataFlags::REFCOUNTED);

    EXPECT_FALSE(foo.GetDataFlags() & DataFlags::REFCOUNTED);

    // First string should be reset, the second should be pointing to the

    // original buffer.

    EXPECT_NE(data, tmp.Data());

    EXPECT_EQ(data, foo.Data());

    EXPECT_TRUE(tmp.IsEmpty());

  }

  {

    // Test copying to a nsCString.

    nsDependentCString tmp("foo");

    auto data = tmp.Data();

    nsCString foo(tmp);

    // Original string should not be shared, copy should be shared.

    EXPECT_FALSE(tmp.GetDataFlags() & DataFlags::REFCOUNTED);

    EXPECT_TRUE(foo.GetDataFlags() & DataFlags::REFCOUNTED);

    // First string should remain the same, the second should be pointing to

    // a new buffer.

    EXPECT_EQ(data, tmp.Data());

    EXPECT_NE(data, foo.Data());

  }

}

TEST_F(Strings, assign)

{

  nsCString result;

  test_assign_helper(NS_LITERAL_CSTRING("a") + NS_LITERAL_CSTRING("b"), result);

  EXPECT_STREQ(result.get(), "ab");

}

TEST_F(Strings, assign_c)

{

  nsCString c; c.Assign('c');

  EXPECT_STREQ(c.get(), "c");

}

TEST_F(Strings, test1)

{

  NS_NAMED_LITERAL_STRING(empty, "");

  const nsAString& aStr = empty;

  nsAutoString buf(aStr);

  int32_t n = buf.FindChar(',');

  EXPECT_EQ(n, kNotFound);

  n = buf.Length();

  buf.Cut(0, n + 1);

  n = buf.FindChar(',');

  EXPECT_EQ(n, kNotFound);

}

TEST_F(Strings, test2)

{

  nsCString data("hello world");

  const nsACString& aStr = data;

  nsCString temp(aStr);

  temp.Cut(0, 6);

  EXPECT_STREQ(temp.get(), "world");

}

TEST_F(Strings, find)

{

  nsCString src("<!DOCTYPE blah blah blah>");

  int32_t i = src.Find("DOCTYPE", true, 2, 1);

  EXPECT_EQ(i, 2);

}

TEST_F(Strings, rfind)

{

  const char text[] = "<!DOCTYPE blah blah blah>";

  const char term[] = "bLaH";

  nsCString src(text);

  int32_t i;

  i = src.RFind(term, true, 3, -1);

  EXPECT_EQ(i, kNotFound);

  i = src.RFind(term, true, -1, -1);

  EXPECT_EQ(i, 20);

  i = src.RFind(term, true, 13, -1);

  EXPECT_EQ(i, 10);

  i = src.RFind(term, true, 22, 3);

  EXPECT_EQ(i, 20);

}

TEST_F(Strings, rfind_2)

{

  const char text[] = "<!DOCTYPE blah blah blah>";

  nsCString src(text);

  int32_t i = src.RFind("TYPE", false, 5, -1);

  EXPECT_EQ(i, 5);

}

TEST_F(Strings, rfind_3)

{

  const char text[] = "urn:mozilla:locale:en-US:necko";

  nsAutoCString value(text);

  int32_t i = value.RFind(":");

  EXPECT_EQ(i, 24);

}

TEST_F(Strings, rfind_4)

{

  nsCString value("a.msf");

  int32_t i = value.RFind(".msf");

  EXPECT_EQ(i, 1);

}

TEST_F(Strings, findinreadable)

{

  const char text[] = "jar:jar:file:///c:/software/mozilla/mozilla_2006_02_21.jar!/browser/chrome/classic.jar!/";

  nsAutoCString value(text);

  nsACString::const_iterator begin, end;

  value.BeginReading(begin);

  value.EndReading(end);

  nsACString::const_iterator delim_begin (begin),

                             delim_end   (end);

  // Search for last !/ at the end of the string

  EXPECT_TRUE(FindInReadable(NS_LITERAL_CSTRING("!/"), delim_begin, delim_end));

  char *r = ToNewCString(Substring(delim_begin, delim_end));

  // Should match the first "!/" but not the last

  EXPECT_NE(delim_end, end);

  EXPECT_STREQ(r, "!/");

  free(r);

  delim_begin = begin;

  delim_end = end;

  // Search for first jar:

  EXPECT_TRUE(FindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end));

  r = ToNewCString(Substring(delim_begin, delim_end));

  // Should not match the first jar:, but the second one

  EXPECT_EQ(delim_begin, begin);

  EXPECT_STREQ(r, "jar:");

  free(r);

  // Search for jar: in a Substring

  delim_begin = begin; delim_begin++;

  delim_end = end;

  EXPECT_TRUE(FindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end));

  r = ToNewCString(Substring(delim_begin, delim_end));

  // Should not match the first jar:, but the second one

  EXPECT_NE(delim_begin, begin);

  EXPECT_STREQ(r, "jar:");

  free(r);

  // Should not find a match

  EXPECT_FALSE(FindInReadable(NS_LITERAL_CSTRING("gecko"), delim_begin, delim_end));

  // When no match is found, range should be empty

  EXPECT_EQ(delim_begin, delim_end);

  // Should not find a match (search not beyond Substring)

  delim_begin = begin; for (int i=0;i<6;i++) delim_begin++;

  delim_end = end;

  EXPECT_FALSE(FindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end));

  // When no match is found, range should be empty

  EXPECT_EQ(delim_begin, delim_end);

  // Should not find a match (search not beyond Substring)

  delim_begin = begin;

  delim_end = end; for (int i=0;i<7;i++) delim_end--;

  EXPECT_FALSE(FindInReadable(NS_LITERAL_CSTRING("classic"), delim_begin, delim_end));

  // When no match is found, range should be empty

  EXPECT_EQ(delim_begin, delim_end);

}

TEST_F(Strings, rfindinreadable)

{

  const char text[] = "jar:jar:file:///c:/software/mozilla/mozilla_2006_02_21.jar!/browser/chrome/classic.jar!/";

  nsAutoCString value(text);

  nsACString::const_iterator begin, end;

  value.BeginReading(begin);

  value.EndReading(end);

  nsACString::const_iterator delim_begin (begin),

                             delim_end   (end);

  // Search for last !/ at the end of the string

  EXPECT_TRUE(RFindInReadable(NS_LITERAL_CSTRING("!/"), delim_begin, delim_end));

  char *r = ToNewCString(Substring(delim_begin, delim_end));

  // Should match the last "!/"

  EXPECT_EQ(delim_end, end);

  EXPECT_STREQ(r, "!/");

  free(r);

  delim_begin = begin;

  delim_end = end;

  // Search for last jar: but not the first one...

  EXPECT_TRUE(RFindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end));

  r = ToNewCString(Substring(delim_begin, delim_end));

  // Should not match the first jar:, but the second one

  EXPECT_NE(delim_begin, begin);

  EXPECT_STREQ(r, "jar:");

  free(r);

  // Search for jar: in a Substring

  delim_begin = begin;

  delim_end = begin; for (int i=0;i<6;i++) delim_end++;

  EXPECT_TRUE(RFindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end));

  r = ToNewCString(Substring(delim_begin, delim_end));

  // Should not match the first jar:, but the second one

  EXPECT_EQ(delim_begin, begin);

  EXPECT_STREQ(r, "jar:");

  free(r);

  // Should not find a match

  delim_begin = begin;

  delim_end = end;

  EXPECT_FALSE(RFindInReadable(NS_LITERAL_CSTRING("gecko"), delim_begin, delim_end));

  // When no match is found, range should be empty

  EXPECT_EQ(delim_begin, delim_end);

  // Should not find a match (search not before Substring)

  delim_begin = begin; for (int i=0;i<6;i++) delim_begin++;

  delim_end = end;

  EXPECT_FALSE(RFindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end));

  // When no match is found, range should be empty

  EXPECT_EQ(delim_begin, delim_end);

  // Should not find a match (search not beyond Substring)

  delim_begin = begin;

  delim_end = end; for (int i=0;i<7;i++) delim_end--;

  EXPECT_FALSE(RFindInReadable(NS_LITERAL_CSTRING("classic"), delim_begin, delim_end));

  // When no match is found, range should be empty

  EXPECT_EQ(delim_begin, delim_end);

}

TEST_F(Strings, distance)

{

  const char text[] = "abc-xyz";

  nsCString s(text);

  nsCString::const_iterator begin, end;

  s.BeginReading(begin);

  s.EndReading(end);

  size_t d = Distance(begin, end);

  EXPECT_EQ(d, sizeof(text) - 1);

}

TEST_F(Strings, length)

{

  const char text[] = "abc-xyz";

  nsCString s(text);

  size_t d = s.Length();

  EXPECT_EQ(d, sizeof(text) - 1);

}

TEST_F(Strings, trim)

{

  const char text[] = " a\t    $   ";

  const char set[] = " \t$";

  nsCString s(text);

  s.Trim(set);

  EXPECT_STREQ(s.get(), "a");

  s.AssignLiteral("\t  \t\t  \t");

  s.Trim(set);

  EXPECT_STREQ(s.get(), "");

  s.AssignLiteral(" ");

  s.Trim(set);

  EXPECT_STREQ(s.get(), "");

  s.AssignLiteral(" ");

  s.Trim(set, false, true);

  EXPECT_STREQ(s.get(), "");

  s.AssignLiteral(" ");

  s.Trim(set, true, false);

  EXPECT_STREQ(s.get(), "");

}

TEST_F(Strings, replace_substr)

{

  const char text[] = "abc-ppp-qqq-ppp-xyz";

  nsCString s(text);

  s.ReplaceSubstring("ppp", "www");

  EXPECT_STREQ(s.get(), "abc-www-qqq-www-xyz");

  s.AssignLiteral("foobar");

  s.ReplaceSubstring("foo", "bar");

  s.ReplaceSubstring("bar", "");

  EXPECT_STREQ(s.get(), "");

  s.AssignLiteral("foofoofoo");

  s.ReplaceSubstring("foo", "foo");

  EXPECT_STREQ(s.get(), "foofoofoo");

  s.AssignLiteral("foofoofoo");

  s.ReplaceSubstring("of", "fo");

  EXPECT_STREQ(s.get(), "fofoofooo");

}

TEST_F(Strings, replace_substr_2)

{

  const char *newName = "user";

  nsString acctName; acctName.AssignLiteral("forums.foo.com");

  nsAutoString newAcctName, oldVal, newVal;

  CopyASCIItoUTF16(mozilla::MakeStringSpan(newName), newVal);

  newAcctName.Assign(acctName);

  // here, oldVal is empty.  we are testing that this function

  // does not hang.  see bug 235355.

  newAcctName.ReplaceSubstring(oldVal, newVal);

  // we expect that newAcctName will be unchanged.

  EXPECT_TRUE(newAcctName.Equals(acctName));

}

TEST_F(Strings, replace_substr_3)

{

  nsCString s;

  s.AssignLiteral("abcabcabc");

  s.ReplaceSubstring("ca", "X");

  EXPECT_STREQ(s.get(), "abXbXbc");

  s.AssignLiteral("abcabcabc");

  s.ReplaceSubstring("ca", "XYZ");

  EXPECT_STREQ(s.get(), "abXYZbXYZbc");

  s.AssignLiteral("abcabcabc");

  s.ReplaceSubstring("ca", "XY");

  EXPECT_STREQ(s.get(), "abXYbXYbc");

  s.AssignLiteral("abcabcabc");

  s.ReplaceSubstring("ca", "XYZ!");

  EXPECT_STREQ(s.get(), "abXYZ!bXYZ!bc");

  s.AssignLiteral("abcdabcdabcd");

  s.ReplaceSubstring("bcd", "X");

  EXPECT_STREQ(s.get(), "aXaXaX");

  s.AssignLiteral("abcdabcdabcd");

  s.ReplaceSubstring("bcd", "XYZ!");

  EXPECT_STREQ(s.get(), "aXYZ!aXYZ!aXYZ!");

  s.AssignLiteral("abcdabcdabcd");

  s.ReplaceSubstring("bcd", "XY");

  EXPECT_STREQ(s.get(), "aXYaXYaXY");

  s.AssignLiteral("abcdabcdabcd");

  s.ReplaceSubstring("bcd", "XYZABC");

  EXPECT_STREQ(s.get(), "aXYZABCaXYZABCaXYZABC");

  s.AssignLiteral("abcdabcdabcd");

  s.ReplaceSubstring("bcd", "XYZ");

  EXPECT_STREQ(s.get(), "aXYZaXYZaXYZ");

  s.AssignLiteral("abcdabcdabcd");

  s.ReplaceSubstring("bcd", "XYZ!");

  EXPECT_STREQ(s.get(), "aXYZ!aXYZ!aXYZ!");

  s.AssignLiteral("abcdabcdabcd");

  s.ReplaceSubstring("ab", "X");

  EXPECT_STREQ(s.get(), "XcdXcdXcd");

  s.AssignLiteral("abcdabcdabcd");

  s.ReplaceSubstring("ab", "XYZABC");

  EXPECT_STREQ(s.get(), "XYZABCcdXYZABCcdXYZABCcd");

  s.AssignLiteral("abcdabcdabcd");

  s.ReplaceSubstring("ab", "XY");

  EXPECT_STREQ(s.get(), "XYcdXYcdXYcd");

  s.AssignLiteral("abcdabcdabcd");

  s.ReplaceSubstring("ab", "XYZ!");

  EXPECT_STREQ(s.get(), "XYZ!cdXYZ!cdXYZ!cd");

  s.AssignLiteral("abcdabcdabcd");

  s.ReplaceSubstring("notfound", "X");

  EXPECT_STREQ(s.get(), "abcdabcdabcd");

  s.AssignLiteral("abcdabcdabcd");

  s.ReplaceSubstring("notfound", "longlongstring");

  EXPECT_STREQ(s.get(), "abcdabcdabcd");

}

TEST_F(Strings, strip_ws)

{

  const char* texts[] = {"",

                         " a    $   ",

                         "Some\fother\t thing\r\n",

                         "And   \f\t\r\n even\nmore\r \f"};

  const char* results[] = {"",

                           "a$",

                           "Someotherthing",

                           "Andevenmore"};

  for (size_t i=0; i<sizeof(texts)/sizeof(texts[0]); i++) {

    nsCString s(texts[i]);

    s.StripWhitespace();

    EXPECT_STREQ(s.get(), results[i]);

  }

}

TEST_F(Strings, equals_ic)

{

  nsCString s;

  EXPECT_FALSE(s.LowerCaseEqualsLiteral("view-source"));

}

TEST_F(Strings, concat)

{

  nsCString bar("bar");

  const nsACString& barRef = bar;

  const nsPromiseFlatCString& result =

      PromiseFlatCString(NS_LITERAL_CSTRING("foo") +

                         NS_LITERAL_CSTRING(",") +

                         barRef);

  EXPECT_STREQ(result.get(), "foo,bar");

}

TEST_F(Strings, concat_2)

{

  nsCString fieldTextStr("xyz");

  nsCString text("text");

  const nsACString& aText = text;

  nsAutoCString result( fieldTextStr + aText );

  EXPECT_STREQ(result.get(), "xyztext");

}

TEST_F(Strings, concat_3)

{

  nsCString result;

  nsCString ab("ab"), c("c");

  result = ab + result + c;

  EXPECT_STREQ(result.get(), "abc");

}

TEST_F(Strings, empty_assign)

{

  nsCString a;

  a.AssignLiteral("");

  a.AppendLiteral("");