github-starred/ultimatepp
2
0
Fork 0
mirror of https://github.com/ultimatepp/ultimatepp.git synced 2026-05-21 06:45:39 -06:00
Code Issues 33 Projects Packages Wiki Activity Actions

git-svn-id: svn://ultimatepp.org/upp/trunk@332 f0d560ea-af0d-0410-9eb7-867de7ffcac7

Browse source
This commit is contained in:
cxl 2008-08-15 10:11:34 +00:00
parent 6842990fa9
commit 2667dfc1d5
385 changed files with 188873 additions and 2 deletions
Download patch file Download diff file Expand all files Collapse all files

45
upptst/BiVector/BiVector.cpp Normal file
View file

@ -0,0 +1,45 @@
#include <Core/Core.h>
using namespace Upp;
CONSOLE_APP_MAIN
{
Vector<int> x;
BiVector<int> y;
for(int i = 0; i < 100000000; i++) {
if(i % 10000 == 0)
Cout() << i << ' ' << x.GetCount() << '\n';
int val = rand();
switch(rand() % 6) {
case 0:
case 1:
x.Add(i);
y.AddTail(i);
break;
case 2:
case 3:
x.Insert(0, i);
y.AddHead(i);
break;
case 4:
if(x.GetCount()) {
x.Drop();
y.DropTail();
}
break;
case 5:
if(x.GetCount()) {
x.Remove(0, 1);
y.DropHead();
}
break;
}
ASSERT(x.GetCount() == y.GetCount());
for(int i = 0; i < x.GetCount(); i++)
ASSERT(x[i] == y[i]);
if(x.GetCount() > 10000) {
x.Clear();
y.Clear();
}
}
}

8
upptst/BiVector/BiVector.upp Normal file
View file

@ -0,0 +1,8 @@
uses
Core;
file
BiVector.cpp;
mainconfig
"" = "";

8
upptst/CParser/CParser.upp Normal file
View file

@ -0,0 +1,8 @@
uses
Core;
file
main.cpp;
mainconfig
"" = "";

4
upptst/CParser/init Normal file
View file

@ -0,0 +1,4 @@
#ifndef _CParser_icpp_init_stub
#define _CParser_icpp_init_stub
#include "Core/init"
#endif

15
upptst/CParser/main.cpp Normal file
View file

@ -0,0 +1,15 @@
#include <Core/Core.h>
using namespace Upp;
CONSOLE_APP_MAIN
{
CParser p("i if while 12345 alfa");
ASSERT(p.Id("i"));
ASSERT(p.Id("if"));
ASSERT(p.Id("while"));
ASSERT(p.IsInt());
ASSERT(p.ReadInt() == 12345);
ASSERT(p.IsId());
ASSERT(p.ReadId() == "alfa");
}

8
upptst/CoWorkImg/CoWorkImg.upp Normal file
View file

@ -0,0 +1,8 @@
uses
CtrlLib;
file
main.cpp;
mainconfig
"" = "GUI MT";

4
upptst/CoWorkImg/init Normal file
View file

@ -0,0 +1,4 @@
#ifndef _CoWorkImg_icpp_init_stub
#define _CoWorkImg_icpp_init_stub
#include "CtrlLib/init"
#endif

32
upptst/CoWorkImg/main.cpp Normal file
View file

@ -0,0 +1,32 @@
#include <CtrlLib/CtrlLib.h>
using namespace Upp;
void DoLine(RGBA *line, int phase, int y, Size sz)
{
// DLOG("DoLine " << (void *)line << ' ' << y << ' ' << phase);
Point c = sz / 2;
c = Point(int(sin((double)phase / 131) * c.x + c.x), int(sin((double)phase / 127) * c.y + c.y));
int yy = (y - c.y) * (y - c.y);
for(int x = 0; x < sz.cx; x++) {
double d = (x - c.x) * (x - c.x) + yy;
line[x] = GrayColor((int)(120 + 120 * sin(d / 1000 - (double)phase / 5)));
}
// DLOG("Done DoLine Phase " << phase << " y " << y);
}
GUI_APP_MAIN
{
for(int phase = 0; phase < 1000000; phase++) {
Size sz = Size(400, 400);
ImageBuffer ib(sz);
{
CoWork co;
for(int y = 0; y < sz.cy; y++)
co & callback4(DoLine, ib[y], phase, y, sz);
}
// DLOG("Finished phase " << phase);
Image m = ib;
}
// App().Run();
}

176
upptst/FileStream/FileStream.cpp Normal file
View file

@ -0,0 +1,176 @@
#include <Core/Core.h>
using namespace Upp;
void PosOverrunTest()
{
String tmpfile = GetTempFileName("pos");
FileOut fo;
if(!fo.Open(tmpfile)) {
Cout() << "PosOverrunTest: error creating file " << tmpfile << "\n";
return;
}
for(int i = 0; i < 0x10000; i++)
fo.PutIW(i);
int64 size = fo.GetSize();
fo.Close();
if(fo.IsError() || size != 0x20000) {
Cout() << "PosOverrunTest generator error, file " << tmpfile << "\n";
return;
}
FileIn fi;
fi.SetBufferSize(4096);
if(!fi.Open(tmpfile)) {
Cout() << "PosOverrunTest: error reopening temporary file " << tmpfile << "\n";
return;
}
for(int i = 0; i < 4096; i++)
fi.Get();
char buffer[32];
fi.GetAll(buffer, 32);
bool ok = true;
for(int i = 0; i < 16; i++) {
int strmval = Peek16le(buffer + 2 * i);
int expect = 2048 + i;
if(strmval != expect) {
Cout() << "PosOverrunTest: " << FormatIntHex(expect, 4) << " expected, " << FormatIntHex(strmval, 4) << " found\n";
ok = false;
}
}
if(ok)
Cout() << "PosOverrunTest: finished without errors\n";
}
enum {
T_READ = 1,
T_READGROUP = 2,
T_WRITE = 4,
T_WRITEGROUP = 8,
T_SEEK = 16
};
String Copy(Stream& s, int spos, int ssize, int tpos, dword style) {
bool lf = dynamic_cast<BlockStream *>(&s);
if(lf) LOG("<<");
if(style & T_SEEK)
s.Seek(spos);
Buffer<byte> b(ssize);
int sz = 0;
if(style & T_READ)
if(style & T_READGROUP) {
while(sz < ssize) {
int c = s.Get();
if(c < 0)
break;
b[sz++] = c;
}
ssize = sz;
}
else
ssize = (int)s.Get(b, ssize);
if(lf) LOG(">>");
if(style & T_SEEK)
s.Seek(tpos);
if(style & T_WRITE)
if(style & T_WRITEGROUP)
for(int i = 0; i < ssize; i++)
s.Put(b[i]);
else
s.Put(b, ssize);
if(style & T_READ)
return String(b, ssize);
return Null;
}
String InFile() { return GetDataFile("FileStream.cpp"); }
void StreamTest() {
FileIn in(InFile());
FileOut out(ConfigFile("chips1.cpp"));
for(;;) {
int c = in.Get();
if(c < 0)
break;
out.Put(c);
}
in.Seek(300);
out.Seek(300);
for(int i = 0; i < 2000; i++)
out.Put(in.Get());
out.SetBufferSize(8);
out.Seek(0);
LOG("================================================");
StringStream ss(LoadFile(InFile()));
int nn = 0;
dword style = 0;
while(nn < 100000000) {
if(++nn % 1000 == 0)
Cout() << "ops: " << nn << ", len: " << ss.GetSize()
<< ", buffersize: " << out.GetBufferSize() << "\n";
if(ss.GetSize() > 256*1024) {
int sz = (rand() % 1000) * 100;
ss.SetSize(sz);
out.SetSize(sz);
LOG("Adjusted size: " << ss.GetSize());
}
if(ss.GetSize() != out.GetSize()) {
DUMP(ss.GetSize());
DUMP(out.GetSize());
Panic("SIZE MISMATCH!");
return;
}
if((rand() & 255) == 0)
{
int64 p = out.GetPos();
out.Seek(0);
if(ss.GetResult() != LoadStream(out)) {
out.Seek(0);
SaveFile(ConfigFile("f1.txt"), LoadStream(out));
SaveFile(ConfigFile("f2.txt"), ss.GetResult());
Panic("CONTENT INEQUAL!");
return;
}
out.Seek(p);
}
int spos = ss.GetSize() ? rand() % (int)ss.GetSize() : 0;
int ssize = rand() % (out.GetBufferSize() * 7);
int tpos = ss.GetSize() ? MAKELONG(rand(), rand()) % (int)ss.GetSize() : 0;
if((rand() & 3) == 0)
tpos = minmax<int>(spos - (rand() & 63) + 32, 0, (int)out.GetSize());
if((rand() & 3) == 0)
ssize = rand() % (3 * out.GetBufferSize());
if((rand() & 4091) == 0) {
style++;
Cout() << "MODE: " << style << "\n";
}
LOG("---------------------");
LOG("spos: " << spos << " ssize: " << ssize << " tpos: " << tpos << " style: " << style);
// DUMP(ss.GetSize());
// DUMP(out.GetSize());
String a = Copy(out, spos, ssize, tpos, style);
String b = Copy(ss, spos, ssize, tpos, style);
// DUMP(ss.GetSize());
// DUMP(out.GetSize());
if((rand() & 1023) == 0)
out.SetBufferSize((rand() & 127) + 2);
if(a != b) {
SaveFile(ConfigFile("f1c.txt"), a);
SaveFile(ConfigFile("f2c.txt"), b);
out.Seek(0);
SaveFile(ConfigFile("f1.txt"), LoadStream(out));
SaveFile(ConfigFile("f2.txt"), ss.GetResult());
DUMP(ss.GetSize());
Panic("INEQUAL READ IN COPY!");
return;
}
}
}
CONSOLE_APP_MAIN
{
// DataBase::FullTest();
PosOverrunTest();
StreamTest();
}

8
upptst/FileStream/FileStream.upp Normal file
View file

@ -0,0 +1,8 @@
uses
Core;
file
FileStream.cpp;
mainconfig
"" = "";

143
upptst/Heap/Heap.cpp Normal file
View file

@ -0,0 +1,143 @@
#include <Core/Core.h>
using namespace Upp;
void HSet(byte *ptr, int sz)
{
if(!ptr) return;
int q = (uintptr_t)ptr % 257;
while(sz--)
*ptr++ = (byte)q++;
}
void HCheck(byte *ptr, int sz)
{
if(!ptr) return;
int q = (uintptr_t)ptr % 257;
while(sz--)
ASSERT(*ptr++ == (byte)q++);
}
int count;
byte *ptr[8192];
size_t sz[8192];
void MCheck()
{
MemoryCheckDebug();
for(int i = 0; i < count; i++)
HCheck(ptr[i], sz[i]);
}
void HClear() {
for(int i = 0; i < count; i++) {
HCheck(ptr[i], sz[i]);
delete ptr[i];
ptr[i] = NULL;
sz[i] = 0;
MCheck();
}
MemoryCheck();
MemoryCheckDebug();
}
void MClear(bool del = false) {
for(int i = 0; i < count; i++) {
HCheck(ptr[i], sz[i]);
MemoryFree(ptr[i]);
ptr[i] = NULL;
sz[i] = 0;
MCheck();
}
MemoryCheck();
MemoryCheckDebug();
}
int RndSize()
{
return rand() & 255;
switch(rand() & 3) {
case 0: return rand() & 255;
case 1: return rand() & 16383;
}
return (rand() + rand() + rand()) & 0x1ffff;
}
void HeapTest(int cnt, int N, bool chk)
{
int mask = cnt - 1;
count = cnt;
memset(ptr, 0, sizeof(ptr));
memset(sz, 0, sizeof(sz));
for(int n = 1; n < N; n++) {
if(n % 1000 == 0)
LOG(n);
int q = n & mask;
if(chk)
MCheck();
else
HCheck(ptr[q], sz[q]);
delete (byte *)ptr[q];
ptr[q] = NULL;
if(chk) MCheck();
sz[q] = RndSize();
ptr[q] = new byte[sz[q]];
HSet(ptr[q], sz[q]);
if(chk) MCheck();
}
HClear();
MCheck();
LOG("Stage 1 (new/delete) passed\r\n");
for(int n2 = 1; n2 < N; n2++) {
if(n2 % 1000 == 0)
LOG(n2);
int q = n2 & mask;
if(chk)
MCheck();
else
HCheck(ptr[q], sz[q]);
// LOGF("Free: %p\n", (void *)ptr[q]);
MemoryFree((byte *)ptr[q]);
ptr[q] = NULL;
if(chk) MCheck();
sz[q] = RndSize();
ptr[q] = (byte *)MemoryAlloc(sz[q]);
// LOGF("Alloc: %d %p\n", sz[q], (void *)ptr[q]);
ASSERT(((int)(uintptr_t)ptr[q] & 15) == 0);
HSet(ptr[q], sz[q]);
if(chk) MCheck();
}
MClear();
LOG("Stage 2 (MemoryAlloc/MemoryFree) passed");
for(int n3 = 1; n3 < N; n3++) {
if(n3 % 1000 == 0)
LOG(n3);
int q = n3 & mask;
if(chk)
MCheck();
else
HCheck(ptr[q], sz[q]);
MemoryFree((byte *)ptr[q]);
ptr[q] = NULL;
if(chk) MCheck();
sz[q] = RndSize();
ptr[q] = (byte *)MemoryAllocSz(sz[q]);
ASSERT(((int)(uintptr_t)ptr[q] & 15) == 0);
HSet(ptr[q], sz[q]);
if(chk) MCheck();
}
MClear();
LOG("Stage 3 (MemoryAllocSz/MemoryFree) passed");
}
CONSOLE_APP_MAIN
{
StdLogSetup(LOG_FILE|LOG_COUT);
LOG("Allocator test:");
HeapTest(256, 100000, true);
LOG("Checked allocator test Passed");
HeapTest(8192, 1000000, false);
LOG("Quick allocator test Passed");
HeapTest(8192, 100 * 1000000, false);
LOG("Allocator test Passed");
}

9
upptst/Heap/Heap.upp Normal file
View file

@ -0,0 +1,9 @@
uses
Core;
file
Heap.cpp;
mainconfig
"" = "";

67
upptst/HeapMT/Heap.cpp Normal file
View file

@ -0,0 +1,67 @@
#include <Core/Core.h>
#define N 1000 * 100
#define THREADS 5
using namespace Upp;
Mutex mutex;
Semaphore todo;
BiVector<int *> queue;
void ProducerThread()
{
for(int i = 0; i < N; i++) {
if(i % 1000 == 0)
LOG(i);
mutex.Enter();
queue.AddHead() = new int;
mutex.Leave();
todo.Release();
MemoryCheckDebug();
}
LOG("Producer shutdown");
}
void ConsumerThread()
{
for(;;) {
todo.Wait();
Mutex::Lock __(mutex);
if(queue.GetCount()) {
int *ptr = queue.Tail();
if(!ptr) break;
queue.DropTail();
delete ptr;
}
MemoryCheckDebug();
}
LOG("Consumer shutdown");
}
CONSOLE_APP_MAIN {
StdLogSetup(LOG_COUT);
Thread producer[THREADS];
Thread consumer[THREADS];
for(int i = 0; i < THREADS; i++) {
producer[i].Run(callback(ProducerThread));
consumer[i].Run(callback(ConsumerThread));
}
for(int i = 0; i < THREADS; i++) {
producer[i].Wait();
LOG("Producer #" << i << " terminated");
}
mutex.Enter();
queue.AddHead(NULL);
mutex.Leave();
for(int i = 0; i < THREADS; i++)
todo.Release();
for(int i = 0; i < THREADS; i++) {
consumer[i].Wait();
LOG("Consumer #" << i << " terminated");
}
MemoryCheckDebug();
LOG("App shutdown");
LOG("Passed");
}

9
upptst/HeapMT/HeapMT.upp Normal file
View file

@ -0,0 +1,9 @@
uses
Core;
file
Heap.cpp;
mainconfig
"" = "MT";

4
upptst/HeapMT/init Normal file
View file

@ -0,0 +1,4 @@
#ifndef _HeapMT_icpp_init_stub
#define _HeapMT_icpp_init_stub
#include "Core/init"
#endif

80
upptst/RWMutex/RWMutex.cpp Normal file
View file

@ -0,0 +1,80 @@
#include <Core/Core.h>
using namespace Upp;
#ifdef PLATFORM_POSIX
__thread int threadid;
#else
__declspec(thread) int threadid;
#endif
#define LLOG(x) LOG((threadid) << " " << x << ", count " << count)
RWMutex rwlock;
VectorMap<int, String> cache;
String Fn(int x)
{
return AsString(sin(sqrt((double)x)));
}
void CheckResult(int x, const String& r)
{
if(r != Fn(x)) {
DUMP(r);
DUMP(Fn(x));
Panic("Failure! " + AsString(threadid));
}
}
int writes, removes;
void WorkThread(int id)
{
threadid = id;
for(int i = 0; i < 1000000; i++) {
if(i % 1000000 == 0)
INTERLOCKED
Cout() << id << ": " << i << ", writes: " << writes << ", removes: " << removes << "\n";
int x = rand() & 0x7fff;
rwlock.EnterRead();
int q = cache.Find(x);
if(q >= 0) {
String r = cache[q];
CheckResult(x, r);
// for(int i = 0; i < 100; i++)
// Fn(x);
rwlock.LeaveRead();
}
else {
rwlock.LeaveRead();
rwlock.EnterWrite();
RTIMING("Write!");
q = cache.Find(x);
if(q >= 0)
CheckResult(x, cache[q]);
else {
writes++;
if(cache.GetCount() >= 0x7ff0) {
removes++;
cache.Remove(0, 100);
}
cache.Add(x, Fn(x));
}
rwlock.LeaveWrite();
}
}
}
CONSOLE_APP_MAIN
{
RTIMING("All");
Thread t[20];
for(int i = 0; i < 9; i++)
t[i].Run(callback1(WorkThread, i + 1));
WorkThread(0);
for(int i = 0; i < 9; i++)
t[i].Wait();
RDUMP(writes);
RDUMP(removes);
}

8
upptst/RWMutex/RWMutex.upp Normal file
View file

@ -0,0 +1,8 @@
uses
Core;
file
RWMutex.cpp;
mainconfig
"" = "MT";

4
upptst/RWMutex/init Normal file
View file

@ -0,0 +1,4 @@
#ifndef _RWMutex_icpp_init_stub
#define _RWMutex_icpp_init_stub
#include "Core/init"
#endif

191
upptst/SqlExp/SqlExp.cpp Normal file
View file

@ -0,0 +1,191 @@
#include <Sql/Sql.h>
using namespace Upp;
SQLID(COLUMN)
SQLID(COLUMN1)
SQLID(COLUMN2)
SQLID(TABLE)
SQLID(TABLE1)
SQLID(TABLE2)
SQLID(SEQ)
SQLID(A)
SQLID(B)
SQLID(C)
SQLID(PH_SEQ)
SQLID(CASTKA)
SQLID(PH_POLOZKA)
SQLID(DATUM)
SQLID(PLAT_DTM)
SQLID(PLAT_DTM_SEQ)
SQLID(SEQ_POPLATEK)
SQLID(PRIPAD_SEQ)
SQLID(TXT)
SQLID(KATASTR_SEQ)
SQLID(ADRESA)
SQLID(ADRESA_SEQ)
SQLID(PAR_ADRESA_SEQ)
SQLID(KONTO)
SQLID(ROK)
SQLID(OBDOBI)
SQLID(KONTO_CON)
void DO(SqlStatement s)
{
LOG(s.Get(ORACLE));
}
void EXP(SqlStatement s, const char *q)
{
ASSERT(s.Get(PGSQL) == q);
}
CONSOLE_APP_MAIN
{
DO(Select(A, B).From(TABLE1, TABLE2).OrderBy(B, C));
DO(Select(A, B).From(TABLE1, TABLE2).Where(A == 10).OrderBy(B, C));
DO(Select(A, B).From(SqlSet(TABLE1, TABLE2)).Where(A == 10).OrderBy(SqlSet(B, C)));
DO(Select(PH_SEQ, SqlSum(CASTKA)).From(PH_POLOZKA).Where(DATUM <= GetSysDate()).GroupBy(PH_SEQ).Having(C == B));
DO(Insert(TABLE1)(A, 1)(B, 2));
DO(Insert(PLAT_DTM)
(PLAT_DTM_SEQ, NextVal(SEQ_POPLATEK))
(PRIPAD_SEQ, 1111)
(DATUM)
(CASTKA)
(TXT)
.From(PLAT_DTM).Where(PRIPAD_SEQ == 2222));
DO(Select(KATASTR_SEQ).From(ADRESA)
.StartWith(PAR_ADRESA_SEQ == 1111)
.ConnectBy(Prior(ADRESA_SEQ) == PAR_ADRESA_SEQ)
| Select(KATASTR_SEQ).From(ADRESA)
.StartWith(ADRESA_SEQ == 2222)
.ConnectBy(Prior(PAR_ADRESA_SEQ) == ADRESA_SEQ));
DO(SqlUpdate(KONTO)(ROK, 1111)(OBDOBI, 2222).Where(KONTO_CON == 3333));
EXP(Select(COLUMN).From(TABLE),
"select COLUMN from TABLE");
EXP(Select(COLUMN.Of(TABLE)).From(TABLE),
"select TABLE.COLUMN from TABLE");
EXP(Select(COLUMN.As(A)).From(TABLE),
"select COLUMN as A from TABLE");
EXP(Select(COLUMN&A).From(TABLE),
"select COLUMN$A from TABLE");
EXP(Select(COLUMN[3]).From(TABLE),
"select COLUMN3 from TABLE");
EXP(Select(COLUMN1 % COLUMN2).From(TABLE),
"select mod(COLUMN1, COLUMN2) from TABLE");
EXP(Select(COLUMN1 | COLUMN2).From(TABLE),
"select COLUMN1 || COLUMN2 from TABLE");
EXP(Select(SqlFunc("any_fn", COLUMN, 2)).From(TABLE),
"select any_fn(COLUMN, 2) from TABLE");
EXP(Select(Distinct(COLUMN)).From(TABLE),
"select distinct COLUMN from TABLE");
EXP(Select(Distinct(SqlSet(COLUMN1, COLUMN2))).From(TABLE),
"select distinct COLUMN1, COLUMN2 from TABLE");
EXP(Select(All(COLUMN)).From(TABLE),
"select all COLUMN from TABLE");
EXP(Select(Count(COLUMN)).From(TABLE),
"select count(COLUMN) from TABLE");
EXP(Select(SqlAll()).From(TABLE),
"select * from TABLE");
EXP(Select(SqlCountRows()).From(TABLE),
"select count(*) from TABLE");
EXP(Select(COLUMN).From(TABLE).OrderBy(Descending(COLUMN)),
"select COLUMN from TABLE order by COLUMN desc");
EXP(Select(SqlMax(COLUMN)).From(TABLE),
"select max(COLUMN) from TABLE");
EXP(Select(SqlMin(COLUMN)).From(TABLE),
"select min(COLUMN) from TABLE");
EXP(Select(SqlSum(COLUMN)).From(TABLE),
"select sum(COLUMN) from TABLE");
EXP(Select(Avg(COLUMN)).From(TABLE),
"select avg(COLUMN) from TABLE");
EXP(Select(Stddev(COLUMN)).From(TABLE),
"select stddev(COLUMN) from TABLE");
EXP(Select(Variance(COLUMN)).From(TABLE),
"select variance(COLUMN) from TABLE");
EXP(Select(Greatest(COLUMN1, COLUMN2)).From(TABLE),
"select greatest(COLUMN1, COLUMN2) from TABLE");
EXP(Select(Least(COLUMN1, COLUMN2)).From(TABLE),
"select least(COLUMN1, COLUMN2) from TABLE");
EXP(Select(Upper(COLUMN)).From(TABLE),
"select upper(COLUMN) from TABLE");
EXP(Select(Lower(COLUMN)).From(TABLE),
"select lower(COLUMN) from TABLE");
EXP(Select(Substr(COLUMN, 1)).From(TABLE),
"select SUBSTR(COLUMN, 1) from TABLE");
EXP(Select(Substr(COLUMN, 2, 1)).From(TABLE),
"select SUBSTR(COLUMN, 2, 1) from TABLE");
EXP(Select(Instr(COLUMN, "hello")).From(TABLE),
"select INSTR(COLUMN, 'hello') from TABLE");
EXP(Select(SqlNvl(COLUMN1, COLUMN2)).From(TABLE),
"select coalesce(COLUMN1, COLUMN2) from TABLE");
EXP(Select(NextVal(SEQ)).Get(),
"select nextval('SEQ')");
EXP(Select(CurrVal(SEQ)).Get(),
"select currval('SEQ')");
EXP(Select(SqlArg()).From(TABLE),
"select ? from TABLE");
EXP(Select(COLUMN).From(TABLE).Where(COLUMN / 2 > 1 && COLUMN1 == "A" || COLUMN2 == Date(2006, 1, 1)),
"select COLUMN from TABLE where COLUMN / 2 > 1 and COLUMN1 = 'A' or COLUMN2 = '2006-01-01'");
EXP(Select(COLUMN).From(TABLE).Where(!(COLUMN == 1)),
"select COLUMN from TABLE where not (COLUMN = 1)");
EXP(Select(COLUMN).From(TABLE).Where((COLUMN1 == 1) - (COLUMN2 == 1)),
"select COLUMN from TABLE where COLUMN1 = 1 and not COLUMN2 = 1");
EXP(Select(COLUMN).From(TABLE).Where(IsNull(COLUMN1)),
"select COLUMN from TABLE where COLUMN1 is NULL");
EXP(Select(COLUMN).From(TABLE).Where(NotNull(COLUMN1)),
"select COLUMN from TABLE where COLUMN1 is not NULL");
EXP(Select(COLUMN).From(TABLE).Where(Like(COLUMN1, Wild("A*"))),
"select COLUMN from TABLE where COLUMN1 ilike 'A%%'");
EXP(Select(COLUMN).From(TABLE).Where(NotLike(COLUMN1, Wild("A*"))),
"select COLUMN from TABLE where COLUMN1 not ilike 'A%%'");
EXP(Select(COLUMN).From(TABLE).Where(In(COLUMN, Select(COLUMN).From(TABLE1))),
"select COLUMN from TABLE where COLUMN in (select COLUMN from TABLE1)");
EXP(Select(COLUMN).From(TABLE).Where(COLUMN == Select(COLUMN).From(TABLE1)),
"select COLUMN from TABLE where COLUMN in (select COLUMN from TABLE1)");
EXP(Select(COLUMN).From(TABLE).Where(NotIn(COLUMN, Select(COLUMN).From(TABLE1))),
"select COLUMN from TABLE where COLUMN not in (select COLUMN from TABLE1)");
EXP(Select(COLUMN).From(TABLE).Where(COLUMN != Select(COLUMN).From(TABLE1)),
"select COLUMN from TABLE where COLUMN not in (select COLUMN from TABLE1)");
EXP(Select(COLUMN).From(TABLE).Where(Exists(Select(COLUMN).From(TABLE1))),
"select COLUMN from TABLE where exists (select COLUMN from TABLE1)");
EXP(Select(COLUMN).From(TABLE).Where(NotExists(Select(COLUMN).From(TABLE1))),
"select COLUMN from TABLE where not exists (select COLUMN from TABLE1)");
EXP(Select(COLUMN).From(TABLE).Where(COLUMN == (Select(COLUMN1).From(TABLE1) | Select(COLUMN2).From(TABLE2))),
"select COLUMN from TABLE where COLUMN in (select COLUMN1 from TABLE1 union (select COLUMN2 from TABLE2))");
EXP(Select(COLUMN).From(TABLE).Where(COLUMN == (Select(COLUMN1).From(TABLE1) & Select(COLUMN2).From(TABLE2))),
"select COLUMN from TABLE where COLUMN in (select COLUMN1 from TABLE1 intersect (select COLUMN2 from TABLE2))");
EXP(Select(COLUMN).From(TABLE).Where(COLUMN == (Select(COLUMN1).From(TABLE1) - Select(COLUMN2).From(TABLE2))),
"select COLUMN from TABLE where COLUMN in (select COLUMN1 from TABLE1 minus (select COLUMN2 from TABLE2))");
EXP(Select(COLUMN).From(TABLE).Where(COLUMN == 0).GroupBy(COLUMN).Having(COLUMN == 0).OrderBy(Descending(COLUMN)),
"select COLUMN from TABLE where COLUMN = 0 group by COLUMN having COLUMN = 0 order by COLUMN desc");
EXP(Select(COLUMN).From(TABLE).Limit(100),
"select COLUMN from TABLE limit 100");
EXP(Select(COLUMN).From(TABLE).Limit(100, 10),
"select COLUMN from TABLE limit 100, 10");
EXP(Select(COLUMN).From(TABLE).Offset(20),
"select COLUMN from TABLE offset 20");
EXP(Select(25 * 34).Get(),
"select 850");
EXP(Select(COLUMN).From(TABLE).Hint("hint"),
"/*+ hint */ select COLUMN from TABLE");
EXP(Select(COLUMN).From(TABLE).InnerJoin(TABLE1).On(COLUMN.Of(TABLE) == COLUMN1.Of(TABLE1)),
"select COLUMN from TABLE inner join TABLE1 on TABLE.COLUMN = TABLE1.COLUMN1");
EXP(Select(COLUMN).From(TABLE).LeftJoin(TABLE1).On(COLUMN.Of(TABLE) == COLUMN1.Of(TABLE1)),
"select COLUMN from TABLE left outer join TABLE1 on TABLE.COLUMN = TABLE1.COLUMN1");
EXP(Select(COLUMN).From(TABLE).RightJoin(TABLE1).On(COLUMN.Of(TABLE) == COLUMN1.Of(TABLE1)),
"select COLUMN from TABLE right outer join TABLE1 on TABLE.COLUMN = TABLE1.COLUMN1");
EXP(Select(COLUMN).From(TABLE).FullJoin(TABLE1).On(COLUMN.Of(TABLE) == COLUMN1.Of(TABLE1)),
"select COLUMN from TABLE full outer join TABLE1 on TABLE.COLUMN = TABLE1.COLUMN1");
EXP(Delete(TABLE).Where(COLUMN < 0),
"delete from TABLE where COLUMN < 0");
EXP(Insert(TABLE)(COLUMN1, 12)(COLUMN2, "hello")(COLUMN, Date(2007, 1, 1)),
"insert into TABLE(COLUMN1, COLUMN2, COLUMN) values (12, 'hello', '2007-01-01')");
EXP(Insert(TABLE)(COLUMN1, 12)(COLUMN2)(COLUMN).From(TABLE1).Where(COLUMN >= 0),
"insert into TABLE(COLUMN1, COLUMN2, COLUMN) select 12, COLUMN2, COLUMN from TABLE1 where COLUMN >= 0");
EXP(Update(TABLE)(COLUMN1, 13)(COLUMN2, "world").Where(COLUMN > Date(2007, 1, 1)),
"update TABLE set COLUMN1 = 13, COLUMN2 = 'world' where COLUMN > '2007-01-01'");
}

10
upptst/SqlExp/SqlExp.upp Normal file
View file

@ -0,0 +1,10 @@
uses
Core,
Sql;
file
SqlExp.cpp;
mainconfig
"" = "";

89
upptst/StableSort/StableSort.cpp Normal file
View file

@ -0,0 +1,89 @@
#include <Core/Core.h>
#include <algorithm>
#include <vector>
using namespace Upp;
#define LLOG(x)
struct Item : Comparable<Item> {
String v;
int i;
int Compare(const Item& b) const { return SgnCompare(v, b.v); }
};
void Benchmark();
void Check(int N, int M)
{
Cout() << "LESS\n";
for(int pass = 0; pass < 2; pass++) {
int i;
Vector<String> k;
Vector<int> v;
StableSort(k);
Cout() << "Testing " << N << ' ' << M << EOL;
for(i = 0; i < N; i++) {
k.Add(AsString(rand() % M));
v.Add(i);
}
Cout() << " GetStableSortOrder..." << EOL;
Vector<int> o = pass ? GetStableSortOrderCmp(k) : GetStableSortOrder(k);
i = 0;
while(i < o.GetCount()) {
LLOG(k[o[i]].v);
if(i > 0)
ASSERT(k[o[i]] >= k[o[i - 1]]);
int j = i;
while(++j < o.GetCount() && k[o[j]] == k[o[i]])
ASSERT(o[j] > o[j - 1]);
i = j;
}
Cout() << " StableIndexSort..." << EOL;
if(pass)
StableIndexSortCmp(k, v);
else
StableIndexSort(k, v);
Cout() << " Testing..." << EOL;
for(i = 0; i < k.GetCount(); i++)
LLOG(k[i] << ' ' << v[i]);
LLOG("----------");
i = 0;
while(i < k.GetCount()) {
LLOG(k[i] << ' ' << v[i]);
if(i > 0)
ASSERT(k[i] >= k[i - 1]);
int j = i;
while(++j < k.GetCount() && k[j] == k[i])
ASSERT(v[j] > v[j - 1]);
i = j;
}
if(pass == 0)
Cout() << "CMP\n";
}
}
CONSOLE_APP_MAIN
{
Check(1000, 100);
Check(1000000, 100);
Check(1000000, 10000);
Check(1000000, 1);
for(int i = 1; i < 30000; i += i)
Check(2000000, i);
}
void CompileCheck()
{
Vector<String> x;
IndexSort(x, x);
IndexSort2(x, x, x);
IndexSort3(x, x, x, x);
StableIndexSort(x, x);
StableIndexSort2(x, x, x);
StableIndexSort3(x, x, x, x);
StableIndexSortCmp(x, x);
StableIndexSort2Cmp(x, x, x);
StableIndexSort3Cmp(x, x, x, x);}

8
upptst/StableSort/StableSort.upp Normal file
View file

@ -0,0 +1,8 @@
uses
Core;
file
StableSort.cpp;
mainconfig
"" = "";

4
upptst/StableSort/init Normal file
View file

@ -0,0 +1,4 @@
#ifndef _StableSort_icpp_init_stub
#define _StableSort_icpp_init_stub
#include "Core/init"
#endif

404
upptst/String/String.cpp Normal file
View file

@ -0,0 +1,404 @@
#include <Core/Core.h>
#define LDUMP(x) // DUMP(x)
using namespace Upp;
#define STEPS 40000000
namespace Upp {
typedef wchar *HT;
template <>
String AsString(const HT& s)
{
return WString(s).ToString();
}
}
template <class Str, class StrBuf>
void ATest()
{
Str x = "0123456789012345";
ASSERT(x.FindFirstOf("654") == 4);
ASSERT(x.FindFirstOf("46") == 4);
ASSERT(x.FindFirstOf("32", 10) == 12);
ASSERT(x.FindFirstOf("23", 10) == 12);
ASSERT(x.Mid(3, 4) == Str("3456"));
ASSERT(x.Mid(3) == Str("3456789012345"));
ASSERT(x.Left(2) == Str("01"));
ASSERT(x.Right(2) == Str("45"));
ASSERT(x.Find('3') == 3);
ASSERT(x.ReverseFind('3') == 13);
ASSERT(x.GetLength() == 16);
ASSERT(x.Begin() + x.GetLength() == x.End());
ASSERT(x[0] == '0');
x.Insert(1, 'a');
ASSERT(x == Str("0a123456789012345"));
x.Insert(2, ~Str("bcd"), 2);
ASSERT(x == Str("0abc123456789012345"));
x.Insert(1, ~Str("_"));
ASSERT(x == Str("0_abc123456789012345"));
x.Insert(1, x);
ASSERT(x == Str("00_abc123456789012345_abc123456789012345"));
x.Remove(1, 24);
ASSERT(x == Str("0123456789012345"));
Str b = "013";
ASSERT(x < b);
ASSERT(x <= b);
ASSERT(x <= x);
ASSERT(x == x);
ASSERT(b > x);
ASSERT(b >= x);
ASSERT(x >= x);
ASSERT(x != b);
ASSERT(x.Compare(b) < 0);
ASSERT(b.Compare(x) > 0);
const char *s = "013";
ASSERT(x < s);
ASSERT(x <= s);
ASSERT(x <= x);
ASSERT(x == x);
ASSERT(s > x);
ASSERT(s >= x);
ASSERT(x >= x);
ASSERT(x != s);
ASSERT(s != x);
ASSERT(s == b);
ASSERT(b == s);
ASSERT(x.Compare(s) < 0);
ASSERT(b.Compare(s) == 0);
ASSERT(!b.IsEqual(x));
ASSERT(b.IsEqual(b));
ASSERT(b.IsEqual(s));
ASSERT(!x.IsEqual(b));
b.Cat("ab");
ASSERT(b == Str("013ab"));
b.Cat("ABCD", 2);
ASSERT(b == Str("013abAB"));
b.Cat('x', 3);
ASSERT(b == Str("013abABxxx"));
x.Cat(b);
ASSERT(x == Str("0123456789012345013abABxxx"));
b.Cat(x, 4);
ASSERT(b == Str("013abABxxx0123"));
b.Cat(~x, ~x + 3);
ASSERT(b == Str("013abABxxx0123012"));
b.Cat((byte *)s, 2);
ASSERT(b == Str("013abABxxx012301201"));
ASSERT((Str().Cat() << 123) == Str("123"));
ASSERT(b.Find(2, "ABc", 1) == 5);
ASSERT(b.Find(2, "ABc", 6) < 0);
ASSERT(b.Find("AB", 0) == 5);
ASSERT(b.Find("AB", 6) == -1);
ASSERT(b.Find(b) == 0);
ASSERT(b.Find(b, 1) < 0);
ASSERT(b.StartsWith("013"));
ASSERT(b.StartsWith(Str("013")));
ASSERT(!b.StartsWith("012"));
ASSERT(!b.StartsWith(Str("012")));
ASSERT(b.StartsWith("012", 2));
ASSERT(b.EndsWith("201"));
ASSERT(b.EndsWith(Str("201")));
ASSERT(!b.EndsWith("202"));
ASSERT(!b.EndsWith(Str("202")));
x = "ab";
b = "12";
ASSERT(x + b == Str("ab12"));
ASSERT(x + "xx" == Str("abxx"));
ASSERT("xx" + x == Str("xxab"));
ASSERT(x + 'z' == Str("abz"));
ASSERT('z' + x == Str("zab"));
ASSERT(x + (int)'z' == Str("abz"));
ASSERT((int)'z' + x == Str("zab"));
Str xx = x;
Str bb = b;
Swap(b, x);
ASSERT(xx == b);
ASSERT(bb == x);
StrBuf sb;
sb.Cat("a");
sb.Cat("1234", 3);
Str sx(sb);
ASSERT(sx == "a123");
sb = bb;
sb[0] = 'a';
bb = sb;
ASSERT(bb == "a2");
}
template <class tchar>
class TStr {
Vector<tchar> v;
bool isvoid;
public:
const tchar *Begin() const { return v.Begin(); }
const tchar *operator~() const { return Begin(); }
operator const char *() const { return v.Begin(); }
tchar *Begin() { return v.Begin(); }
tchar *operator~() { return Begin(); }
operator tchar *() { return v.Begin(); }
TStr& operator=(const TStr& s) { v <<= s.v; isvoid = s.isvoid; return *this; }
void Init() { v.Add(0); isvoid = false; }
TStr() { Init(); }
TStr(const tchar *s) { TStr h = *this; Init(); while(*s) Cat(*s++); }
TStr(const tchar *s, int count) { Init(); while(count--) Cat(*s++); }
TStr(const TStr& s) { Init(); v <<= s.v; isvoid = s.isvoid; }
void Cat(int c) { v.Top() = c; v.Add(0); isvoid = false; }
void Insert(int pos, const tchar *s, int count) {
Vector<tchar> vv(v, 1);
vv.InsertN(pos, count);
while(count--)
vv[pos++] = *s++;
v = vv;
isvoid = false;
}
void Cat(const tchar *s, int count) {
TStr h(*this);
while(count--)
h.Cat(*s++);
*this = h;
}
void Remove(int pos, int count) { v.Remove(pos, count); v[GetCount()] = 0; isvoid = false; }
void Trim(int pos) { v.SetCount(pos + 1); v[pos] = 0; isvoid = false; }
void Set(int pos, int c) { v[pos] = c; isvoid = false; }
void Clear() { v.Clear(); Init(); }
void Strlen() {
for(int i = 0; i < GetCount(); i++)
if(v[i] == 0) {
Trim(i);
break;
}
isvoid = false;
}
void SetLength(int n) { v.SetCount(n + 1); v[n] = 0; isvoid = false; }
int GetLength() const { return v.GetCount() - 1; }
int GetCount() const { return v.GetCount() - 1; }
tchar& operator[](int i) { return v[i]; }
static TStr GetVoid() { TStr x; x.isvoid = true; return x; }
bool IsVoid() const { return isvoid; }
String ToString() const {
String x;
for(int i = 0; i < v.GetCount(); i++)
x.Cat(v[i]);
return x;
}
};
template <class NewString, class NewStringBuffer, class tchar>
void UnitTest()
{
typedef TStr<tchar> String;
typedef TStr<tchar> StringBuffer;
String x;
for(int q = 4; q--;)
for(int c = 32; c < 128; c++)
x.Cat(c);
const tchar *ins = ~x;
String ss, css;
NewString ns, cns;
int size = 40 * 1024 * 1024;
int size2 = 600;
int maxlen = 0;
for(int n = 0; n < STEPS; n++) {
NewString zerotest;
if(n % 1000000 == 0) {
Cout() << n << ", maxlen: " << maxlen << "\r\n";
maxlen = 0;
}
// if(n == 86)
// Cout() << "Now!";
if(ss.GetCount() > maxlen)
maxlen = ss.GetCount();
if(ss.GetCount() > size) {
ss.Clear();
ns.Clear();
if(rand() % 2000 == 0) {
ss = String::GetVoid();
ns = NewString::GetVoid();
}
Swap(size, size2);
}
int ch = rand() % 96 + 32;
int pos = rand() % (ss.GetCount() + 1);
int cpos = Upp::max(0, pos - 1);
int icount = rand() % 160;
int pos2 = rand() % (ss.GetCount() + 1);
int rcount = rand() % (ss.GetCount() - pos + 1);
int op = rand() % 30;
LDUMP(n);
LDUMP(op);
switch(op) {
default:
ss.Cat(ch);
ns.Cat(ch);
break;
case 1:
ss.Insert(pos, ins, icount);
ns.Insert(pos, ins, icount);
break;
case 2:
ss.Remove(pos, rcount);
ns.Remove(pos, rcount);
break;
case 8:
case 20:
case 21:
case 22:
case 23:
case 24:
case 25:
case 26:
ss.Insert(pos2, ~ss + pos, rcount);
ns.Insert(pos2, ~ns + pos, rcount);
break;
case 3:
ss.Cat(ins, icount);
ns.Cat(ins, icount);
break;
case 4: {
String sh = ss;
NewString nh = ns;
ss.Insert(pos, sh.Begin(), sh.GetCount());
ns.Insert(pos, nh.Begin(), nh.GetCount());
}
break;
case 5:
ss = String(ss.Begin() + pos, rcount);
ns = NewString(ns.Begin() + pos, rcount);
break;
case 6:
css = ss;
cns = ns;
break;
case 7:
ss = css;
ns = cns;
break;
case 9:
if(ss.GetLength()) {
ss.Set(cpos, ch);
ns.Set(cpos, ch);
}
break;
case 10:
ss.Trim(pos);
ns.Trim(pos);
break;
case 11:
if(ss.GetLength()) {
StringBuffer sb = ss;
sb[cpos] = 'X';
ss = sb;
NewStringBuffer nb(ns);
nb[cpos] = 'X';
ns = nb;
}
break;
case 12:
if(ss.GetLength()) {
String h = ss;
StringBuffer sb = ss;
sb.Cat(h.Begin() + pos, rcount);
ss = sb;
NewStringBuffer nb(ns);
nb.Cat(nb.Begin() + pos, rcount);
ns = nb;
}
break;
case 14:
ss = ss;
ns = ns;
break;
case 15:
ss = ~ss + pos;
ns = ~ns + pos;
break;
case 13:
NewStringBuffer nb;
StringBuffer sb;
nb.SetLength(1000);
sb.SetLength(1000);
const char *s = "Hello!";
tchar *a = nb;
tchar *b = sb;
while(*s) {
*a++ = *s;
*b++ = *s;
s++;
}
*a = *b = 0;
nb.Strlen();
sb.Strlen();
ns = nb;
ss = sb;
break;
}
MemoryCheck();
NewString s(~ns, ns.GetCount());
MemoryCheck();
LDUMP(ss.Begin());
LDUMP(ns.Begin());
LDUMP(ss.GetLength());
LDUMP(ns.GetCount());
LDUMP(css.GetLength());
LDUMP(cns.GetCount());
LDUMP(String(ns.Begin(), ns.GetCount()));
LDUMP(String(cns.Begin(), cns.GetCount()));
ASSERT(ns[ns.GetCount()] == 0);
ASSERT(cns[cns.GetCount()] == 0);
ASSERT(ss[ns.GetCount()] == 0);
ASSERT(memcmp(ns.Begin(), ss.Begin(), sizeof(tchar) * ns.GetCount() + 1) == 0);
ASSERT(memcmp(cns.Begin(), css.Begin(), sizeof(tchar) * cns.GetCount() + 1) == 0);
ASSERT(GetHashValue(ns) == GetHashValue(NewString(~ns, ns.GetCount())));
ASSERT(ns.IsVoid() == ss.IsVoid());
}
Cout() << "Passed";
RLOG("Test passed");
}
template <class NewString, class StringBuffer, class tchar>
void TestBufferCat()
{
typedef TStr<tchar> String;
for(int n = 0; n < 2000; n++) {
StringBuffer *b = new StringBuffer;
String ss;
for(int x = 0; x < n; x++) {
int c = rand();
b->Cat(c);
ss.Cat(c);
b->Begin();
}
NewString ns = *b;
// LOGHEXDUMP(ns.Begin(), ns.GetCount());
// LOGHEXDUMP(ss.Begin(), ss.GetCount());
ASSERT(ss.GetLength() == ns.GetLength());
ASSERT(memcmp(ns.Begin(), ss.Begin(), sizeof(tchar) * ns.GetCount() + 1) == 0);
delete b;
}
}
CONSOLE_APP_MAIN
{
ATest<String, StringBuffer>();
TestBufferCat<String, StringBuffer, char>();
TestBufferCat<WString, WStringBuffer, wchar>();
// ATest<WString, WStringBuffer>();
UnitTest<String, StringBuffer, char>();
UnitTest<WString, WStringBuffer, wchar>();
}

9
upptst/String/String.upp Normal file
View file

@ -0,0 +1,9 @@
uses
Core;
file
String.cpp;
mainconfig
"" = "";

38
upptst/StringCompare/StringCompare.cpp Normal file
View file

@ -0,0 +1,38 @@
#include <Core/Core.h>
#define LDUMP(x)
#define LLOGHEXDUMP(a, b)
using namespace Upp;
#define N 10000000
CONSOLE_APP_MAIN
{
for(int q = 0; q < N; q++) {
LDUMP(q);
if(q % 10000 == 0)
Cout() << q << '\n';
int eq = rand() % 40;
int l1 = rand() % 40;
int l2 = rand() % 40;
String a, b;
for(int i = 0; i < eq; i++)
a.Cat(rand() % 254 + 1);
b = a;
ASSERT(a.Compare(b) == 0);
for(int i = 0; i < l1; i++)
a.Cat(rand() % 254 + 1);
for(int i = 0; i < l2; i++)
b.Cat(rand() % 254 + 1);
int l = min(l1, l2) + eq;
LLOGHEXDUMP(a, a.GetLength());
LLOGHEXDUMP(b, b.GetLength());
LDUMP(a.Compare(b));
LDUMP(strcmp(a, b));
LDUMP(strcmp(~a, ~b));
ASSERT(sgn(strcmp(a, b)) == sgn(a.Compare(b)));
ASSERT(a.Compare(a) == 0);
ASSERT(b.Compare(b) == 0);
}
}

9
upptst/StringCompare/StringCompare.upp Normal file
View file

@ -0,0 +1,9 @@
uses
Core;
file
StringCompare.cpp;
mainconfig
"" = "";