Involve more log compression techniques.

test/cctest/test-log-utils.cc

 // Copyright 2006-2009 the V8 project authors. All rights reserved.
 //
 // Tests of logging utilities from log-utils.h
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 
 #include "v8.h"
 
 #include "log-utils.h"
 #include "cctest.h"
@@ skipping 121 matching lines @@
   // Check the seal.
   EmbeddedVector<char, 50> seal_buf;
   CHECK_EQ(seal_size, ReadData(&dynabuf, 100, &seal_buf));
   CHECK_EQ(CStrVector(seal), seal_buf.SubVector(0, seal_size));
   // Verify that there's no data beyond the seal.
   CHECK_EQ(0, ReadData(&dynabuf, 100 + seal_size, &buf));
 }
 
 
 TEST(CompressorStore) {
-  LogRecordCompressor comp(2, 0);
+  LogRecordCompressor comp(2);
   const Vector<const char> empty = CStrVector("");
   CHECK(comp.Store(empty));
   CHECK(!comp.Store(empty));
   CHECK(!comp.Store(empty));
   const Vector<const char> aaa = CStrVector("aaa");
   CHECK(comp.Store(aaa));
   CHECK(!comp.Store(aaa));
   CHECK(!comp.Store(aaa));
   CHECK(comp.Store(empty));
   CHECK(!comp.Store(empty));
   CHECK(!comp.Store(empty));
 }
 
 
 void CheckCompression(LogRecordCompressor* comp,
                       const Vector<const char>& after) {
   EmbeddedVector<char, 100> result;
   CHECK(comp->RetrievePreviousCompressed(&result));
   CHECK_EQ(after, result);
 }
 
 
 void CheckCompression(LogRecordCompressor* comp,
                       const char* after) {
   CheckCompression(comp, CStrVector(after));
 }
 
 
 TEST(CompressorNonCompressed) {
-  LogRecordCompressor comp(2, 0);
+  LogRecordCompressor comp(0);
   CHECK(!comp.RetrievePreviousCompressed(NULL));
   const Vector<const char> empty = CStrVector("");
   CHECK(comp.Store(empty));
   CHECK(!comp.RetrievePreviousCompressed(NULL));
   const Vector<const char> a_x_20 = CStrVector("aaaaaaaaaaaaaaaaaaaa");
   CHECK(comp.Store(a_x_20));
   CheckCompression(&comp, empty);
   CheckCompression(&comp, empty);
   CHECK(comp.Store(empty));
   CheckCompression(&comp, a_x_20);
   CheckCompression(&comp, a_x_20);
 }
 
 
 TEST(CompressorSingleLine) {
-  LogRecordCompressor comp(3, strlen("xxx,"));
+  LogRecordCompressor comp(1);
   const Vector<const char> string_1 = CStrVector("eee,ddd,ccc,bbb,aaa");
   CHECK(comp.Store(string_1));
   const Vector<const char> string_2 = CStrVector("fff,ddd,ccc,bbb,aaa");
   CHECK(comp.Store(string_2));
   // string_1 hasn't been compressed.
   CheckCompression(&comp, string_1);
   CheckCompression(&comp, string_1);
   const Vector<const char> string_3 = CStrVector("hhh,ggg,ccc,bbb,aaa");
   CHECK(comp.Store(string_3));
   // string_2 compressed using string_1.
-  CheckCompression(&comp, "fff,#1:4");
-  CheckCompression(&comp, "fff,#1:4");
+  CheckCompression(&comp, "fff#1:3");
+  CheckCompression(&comp, "fff#1:3");
   CHECK(!comp.Store(string_3));
   // Expecting no changes.
-  CheckCompression(&comp, "fff,#1:4");
+  CheckCompression(&comp, "fff#1:3");
   CHECK(!comp.Store(string_3));
   // Expecting no changes.
-  CheckCompression(&comp, "fff,#1:4");
+  CheckCompression(&comp, "fff#1:3");
   const Vector<const char> string_4 = CStrVector("iii,hhh,ggg,ccc,bbb,aaa");
   CHECK(comp.Store(string_4));
   // string_3 compressed using string_2.
   CheckCompression(&comp, "hhh,ggg#1:7");
   const Vector<const char> string_5 = CStrVector("nnn,mmm,lll,kkk,jjj");
   CHECK(comp.Store(string_5));
   // string_4 compressed using string_3.
-  CheckCompression(&comp, "iii,#1:0");
+  CheckCompression(&comp, "iii,#1");
   const Vector<const char> string_6 = CStrVector("nnn,mmmmmm,lll,kkk,jjj");
   CHECK(comp.Store(string_6));
   // string_5 hasn't been compressed.
   CheckCompression(&comp, string_5);
   CHECK(comp.Store(string_5));
   // string_6 compressed using string_5.
   CheckCompression(&comp, "nnn,mmm#1:4");
   const Vector<const char> string_7 = CStrVector("nnnnnn,mmm,lll,kkk,jjj");
   CHECK(comp.Store(string_7));
   // string_5 compressed using string_6.
   CheckCompression(&comp, "nnn,#1:7");
   const Vector<const char> string_8 = CStrVector("xxn,mmm,lll,kkk,jjj");
   CHECK(comp.Store(string_8));
   // string_7 compressed using string_5.
-  CheckCompression(&comp, "nnnn#1:1");
+  CheckCompression(&comp, "nnn#1");
   const Vector<const char> string_9 =
       CStrVector("aaaaaaaaaaaaa,bbbbbbbbbbbbbbbbb");
   CHECK(comp.Store(string_9));
   // string_8 compressed using string_7.
-  CheckCompression(&comp, "xxn,#1:7");
+  CheckCompression(&comp, "xx#1:5");
   const Vector<const char> string_10 =
       CStrVector("aaaaaaaaaaaaa,cccccccbbbbbbbbbb");
   CHECK(comp.Store(string_10));
   // string_9 hasn't been compressed.
   CheckCompression(&comp, string_9);
   CHECK(comp.Store(string_1));
   // string_10 compressed using string_9.
   CheckCompression(&comp, "aaaaaaaaaaaaa,ccccccc#1:21");
 }
 
 
 
 TEST(CompressorMultiLines) {
-  const int kWindowSize = 5;
-  LogRecordCompressor comp(kWindowSize, strlen("xxx,"));
+  const int kWindowSize = 3;
+  LogRecordCompressor comp(kWindowSize);
   const Vector<const char> string_1 = CStrVector("eee,ddd,ccc,bbb,aaa");
   CHECK(comp.Store(string_1));
   const Vector<const char> string_2 = CStrVector("iii,hhh,ggg,fff,aaa");
   CHECK(comp.Store(string_2));
   const Vector<const char> string_3 = CStrVector("mmm,lll,kkk,jjj,aaa");
   CHECK(comp.Store(string_3));
   const Vector<const char> string_4 = CStrVector("nnn,hhh,ggg,fff,aaa");
   CHECK(comp.Store(string_4));
   const Vector<const char> string_5 = CStrVector("ooo,lll,kkk,jjj,aaa");
   CHECK(comp.Store(string_5));
   // string_4 compressed using string_2.
-  CheckCompression(&comp, "nnn,#2:4");
+  CheckCompression(&comp, "nnn#2:3");
   CHECK(comp.Store(string_1));
   // string_5 compressed using string_3.
-  CheckCompression(&comp, "ooo,#2:4");
+  CheckCompression(&comp, "ooo#2:3");
   CHECK(comp.Store(string_4));
   // string_1 is out of buffer by now, so it shouldn't be compressed.
-  CHECK_GE(5, kWindowSize);
+  CHECK_GE(3, kWindowSize);
   CheckCompression(&comp, string_1);
   CHECK(comp.Store(string_2));
   // string_4 compressed using itself.
-  CheckCompression(&comp, "nnn,#3:4");
+  CheckCompression(&comp, "#3");
 }
 
 
 TEST(CompressorBestSelection) {
-  LogRecordCompressor comp(5, strlen("xxx,"));
+  LogRecordCompressor comp(3);
   const Vector<const char> string_1 = CStrVector("eee,ddd,ccc,bbb,aaa");
   CHECK(comp.Store(string_1));
   const Vector<const char> string_2 = CStrVector("ddd,ccc,bbb,aaa");
   CHECK(comp.Store(string_2));
   const Vector<const char> string_3 = CStrVector("fff,eee,ddd,ccc,bbb,aaa");
   CHECK(comp.Store(string_3));
   // string_2 compressed using string_1.
-  CheckCompression(&comp, "ddd,#1:8");
+  CheckCompression(&comp, "#1:4");
   const Vector<const char> string_4 = CStrVector("nnn,hhh,ggg,fff,aaa");
   CHECK(comp.Store(string_4));
   // Compressing string_3 using string_1 gives a better compression than
   // using string_2.
-  CheckCompression(&comp, "fff,#2:0");
+  CheckCompression(&comp, "fff,#2");
+}
+
+
+TEST(CompressorCompressibility) {
+  LogRecordCompressor comp(2);
+  const Vector<const char> string_1 = CStrVector("eee,ddd,ccc,bbb,aaa");
+  CHECK(comp.Store(string_1));
+  const Vector<const char> string_2 = CStrVector("ccc,bbb,aaa");
+  CHECK(comp.Store(string_2));
+  const Vector<const char> string_3 = CStrVector("aaa");
+  CHECK(comp.Store(string_3));
+  // string_2 compressed using string_1.
+  CheckCompression(&comp, "#1:8");
+  const Vector<const char> string_4 = CStrVector("xxx");
+  CHECK(comp.Store(string_4));
+  // string_3 can't be compressed using string_2 --- too short.
+  CheckCompression(&comp, string_3);
 }
 
 #endif  // ENABLE_LOGGING_AND_PROFILING