diff options
author | Mike Buland <eichlan@xagasoft.com> | 2011-03-30 22:33:41 +0000 |
---|---|---|
committer | Mike Buland <eichlan@xagasoft.com> | 2011-03-30 22:33:41 +0000 |
commit | 4b9289cfb260f4bcecaf23a810584ef6ef8e8501 (patch) | |
tree | 79136af08c7e42ba3322f0d73e9779e4354b318a | |
parent | c7636dc954eddfe58f7959392602fbc9072d77e7 (diff) | |
download | libbu++-4b9289cfb260f4bcecaf23a810584ef6ef8e8501.tar.gz libbu++-4b9289cfb260f4bcecaf23a810584ef6ef8e8501.tar.bz2 libbu++-4b9289cfb260f4bcecaf23a810584ef6ef8e8501.tar.xz libbu++-4b9289cfb260f4bcecaf23a810584ef6ef8e8501.zip |
Ok, string stuff is working much, much better, a load of new unit tests have
been added, and I deleted a whole slew of stupid old tests that I don't need.
58 files changed, 1648 insertions, 3436 deletions
diff --git a/src/optparser.cpp b/src/optparser.cpp index bab93d0..74aba3e 100644 --- a/src/optparser.cpp +++ b/src/optparser.cpp | |||
@@ -167,6 +167,68 @@ void Bu::OptParser::parse( int argc, char **argv ) | |||
167 | } | 167 | } |
168 | } | 168 | } |
169 | 169 | ||
170 | void Bu::OptParser::parse( const Bu::String &sLine ) | ||
171 | { | ||
172 | Bu::String sCmd = sLine.clone(); | ||
173 | int iParams = 0; | ||
174 | bool bInGap = true; | ||
175 | bool bInQuote = false; | ||
176 | for( Bu::String::iterator i = sCmd.begin(); i; i++ ) | ||
177 | { | ||
178 | if( bInQuote == false && (*i == ' ' || *i == '\t') ) | ||
179 | { | ||
180 | if( bInGap == false ) | ||
181 | { | ||
182 | bInGap = true; | ||
183 | } | ||
184 | } | ||
185 | else if( *i == '"' ) | ||
186 | { | ||
187 | bInQuote = !bInQuote; | ||
188 | } | ||
189 | else | ||
190 | { | ||
191 | if( bInGap ) | ||
192 | { | ||
193 | iParams++; | ||
194 | bInGap = false; | ||
195 | } | ||
196 | } | ||
197 | } | ||
198 | |||
199 | bInQuote = false; | ||
200 | bInGap = true; | ||
201 | char **asParam = new char*[iParams]; | ||
202 | iParams = 0; | ||
203 | for( char *i = sCmd.getStr(); *i; i++ ) | ||
204 | { | ||
205 | if( bInQuote == false && (*i == ' ' || *i == '\t') ) | ||
206 | { | ||
207 | if( bInGap == false ) | ||
208 | { | ||
209 | bInGap = true; | ||
210 | *i = '\0'; | ||
211 | } | ||
212 | } | ||
213 | else if( *i == '"' ) | ||
214 | { | ||
215 | bInQuote = !bInQuote; | ||
216 | } | ||
217 | else | ||
218 | { | ||
219 | if( bInGap ) | ||
220 | { | ||
221 | asParam[iParams++] = i; | ||
222 | bInGap = false; | ||
223 | } | ||
224 | } | ||
225 | } | ||
226 | |||
227 | parse( iParams, asParam ); | ||
228 | |||
229 | delete[] asParam; | ||
230 | } | ||
231 | |||
170 | void Bu::OptParser::addOption( const Option &opt ) | 232 | void Bu::OptParser::addOption( const Option &opt ) |
171 | { | 233 | { |
172 | lOption.append( opt ); | 234 | lOption.append( opt ); |
diff --git a/src/optparser.h b/src/optparser.h index 2033850..f2fe531 100644 --- a/src/optparser.h +++ b/src/optparser.h | |||
@@ -133,6 +133,7 @@ namespace Bu | |||
133 | virtual ~OptParser(); | 133 | virtual ~OptParser(); |
134 | 134 | ||
135 | void parse( int argc, char **argv ); | 135 | void parse( int argc, char **argv ); |
136 | void parse( const Bu::String &sLine ); | ||
136 | 137 | ||
137 | void addOption( const Option &opt ); | 138 | void addOption( const Option &opt ); |
138 | 139 | ||
diff --git a/src/string.cpp b/src/string.cpp index 5834da1..edc45f9 100644 --- a/src/string.cpp +++ b/src/string.cpp | |||
@@ -443,7 +443,7 @@ Bu::String Bu::String::replace( const Bu::String &fnd, | |||
443 | const_iterator o = begin(); | 443 | const_iterator o = begin(); |
444 | while( true ) | 444 | while( true ) |
445 | { | 445 | { |
446 | const_iterator i = o.find( fnd ); | 446 | const_iterator i = o.find( fnd, fnd.getSize() ); |
447 | if( !i ) | 447 | if( !i ) |
448 | { | 448 | { |
449 | out.append( o ); | 449 | out.append( o ); |
@@ -994,7 +994,7 @@ Bu::String::const_iterator Bu::String::find( const String &rStr, | |||
994 | if( !iStart ) iStart = begin(); | 994 | if( !iStart ) iStart = begin(); |
995 | for( ; iStart; iStart++ ) | 995 | for( ; iStart; iStart++ ) |
996 | { | 996 | { |
997 | if( iStart.compare( rStr, rStr.getSize() ) ) | 997 | if( iStart.compare( rStr ) ) |
998 | return iStart; | 998 | return iStart; |
999 | } | 999 | } |
1000 | return end(); | 1000 | return end(); |
@@ -1133,6 +1133,36 @@ void Bu::String::trimBack( long iAmnt ) | |||
1133 | core->nLength -= iAmnt; | 1133 | core->nLength -= iAmnt; |
1134 | } | 1134 | } |
1135 | 1135 | ||
1136 | Bu::String Bu::String::trimWhitespace() const | ||
1137 | { | ||
1138 | if( core->nLength == 0 ) | ||
1139 | return ""; | ||
1140 | const_iterator i = begin(); | ||
1141 | for( ; i && (*i == ' ' || *i == '\t' || *i == '\n' || *i == '\r'); i++ ) { } | ||
1142 | if( !i ) | ||
1143 | return ""; | ||
1144 | |||
1145 | const_iterator e = i; | ||
1146 | for( ; e; e++ ) | ||
1147 | { | ||
1148 | if( *e == ' ' || *e == '\t' || *e == '\n' || *e == '\r' ) | ||
1149 | { | ||
1150 | const_iterator t = e; | ||
1151 | for( ; t && (*t == ' ' || *t == '\t' || *t == '\n' || *t == '\r'); t++ ) { } | ||
1152 | if( t ) | ||
1153 | { | ||
1154 | e = t; | ||
1155 | } | ||
1156 | else | ||
1157 | { | ||
1158 | break; | ||
1159 | } | ||
1160 | } | ||
1161 | } | ||
1162 | |||
1163 | return Bu::String( i, e ); | ||
1164 | } | ||
1165 | |||
1136 | Bu::String::iterator Bu::String::begin() | 1166 | Bu::String::iterator Bu::String::begin() |
1137 | { | 1167 | { |
1138 | if( core->nLength == 0 ) | 1168 | if( core->nLength == 0 ) |
diff --git a/src/string.h b/src/string.h index 3ac161b..2874e37 100644 --- a/src/string.h +++ b/src/string.h | |||
@@ -117,6 +117,13 @@ namespace Bu | |||
117 | iPos = i.iPos; | 117 | iPos = i.iPos; |
118 | return *this; | 118 | return *this; |
119 | } | 119 | } |
120 | |||
121 | const_iterator &operator=( const iterator &i ) | ||
122 | { | ||
123 | pChunk = i.pChunk; | ||
124 | iPos = i.iPos; | ||
125 | return *this; | ||
126 | } | ||
120 | 127 | ||
121 | const_iterator &operator++() | 128 | const_iterator &operator++() |
122 | { | 129 | { |
@@ -203,7 +210,8 @@ namespace Bu | |||
203 | if( *a != *b ) | 210 | if( *a != *b ) |
204 | return false; | 211 | return false; |
205 | } | 212 | } |
206 | 213 | if( (bool)a != (bool)b ) | |
214 | return false; | ||
207 | return true; | 215 | return true; |
208 | } | 216 | } |
209 | 217 | ||
@@ -213,14 +221,11 @@ namespace Bu | |||
213 | const_iterator b = c; | 221 | const_iterator b = c; |
214 | if( a == b ) | 222 | if( a == b ) |
215 | return true; | 223 | return true; |
216 | int j; | 224 | for(int j = 0; j < nLen; a++, b++, j++ ) |
217 | for( j = 0; a && b && j < nLen; a++, b++, j++ ) | ||
218 | { | 225 | { |
219 | if( *a != *b ) | 226 | if( !a || !b || *a != *b ) |
220 | return false; | 227 | return false; |
221 | } | 228 | } |
222 | if( j < nLen ) | ||
223 | return false; | ||
224 | return true; | 229 | return true; |
225 | } | 230 | } |
226 | 231 | ||
@@ -256,7 +261,7 @@ namespace Bu | |||
256 | bool compare( const String &s ) const | 261 | bool compare( const String &s ) const |
257 | { | 262 | { |
258 | if( !pChunk ) return false; | 263 | if( !pChunk ) return false; |
259 | return compare( s.begin(), s.getSize() ); | 264 | return compare( s.begin() ); |
260 | } | 265 | } |
261 | 266 | ||
262 | bool compare( const String &s, int nLen ) const | 267 | bool compare( const String &s, int nLen ) const |
@@ -442,10 +447,10 @@ namespace Bu | |||
442 | return pChunk != NULL; | 447 | return pChunk != NULL; |
443 | } | 448 | } |
444 | 449 | ||
445 | bool compare( const iterator &c ) const | 450 | bool compare( const const_iterator &c ) const |
446 | { | 451 | { |
447 | iterator a = *this; | 452 | const_iterator a( *this ); |
448 | iterator b = c; | 453 | const_iterator b = c; |
449 | if( a == b ) | 454 | if( a == b ) |
450 | return true; | 455 | return true; |
451 | for(; a && b; a++, b++ ) | 456 | for(; a && b; a++, b++ ) |
@@ -453,23 +458,22 @@ namespace Bu | |||
453 | if( *a != *b ) | 458 | if( *a != *b ) |
454 | return false; | 459 | return false; |
455 | } | 460 | } |
461 | if( (bool)a != (bool)b ) | ||
462 | return false; | ||
456 | return true; | 463 | return true; |
457 | } | 464 | } |
458 | 465 | ||
459 | bool compare( const iterator &c, int nLen ) const | 466 | bool compare( const const_iterator &c, int nLen ) const |
460 | { | 467 | { |
461 | iterator a = *this; | 468 | const_iterator a( *this ); |
462 | iterator b = c; | 469 | const_iterator b = c; |
463 | if( a == b ) | 470 | if( a == b ) |
464 | return true; | 471 | return true; |
465 | int j; | 472 | for(int j = 0; j < nLen; a++, b++, j++ ) |
466 | for( j = 0; a && b && j < nLen; a++, b++, j++ ) | ||
467 | { | 473 | { |
468 | if( *a != *b ) | 474 | if( !a || !b || *a != *b ) |
469 | return false; | 475 | return false; |
470 | } | 476 | } |
471 | if( j < nLen ) | ||
472 | return false; | ||
473 | return true; | 477 | return true; |
474 | } | 478 | } |
475 | 479 | ||
@@ -505,7 +509,7 @@ namespace Bu | |||
505 | bool compare( const String &s ) const | 509 | bool compare( const String &s ) const |
506 | { | 510 | { |
507 | if( !pChunk ) return false; | 511 | if( !pChunk ) return false; |
508 | return compare( s.begin(), s.getSize() ); | 512 | return compare( s.begin() ); |
509 | } | 513 | } |
510 | 514 | ||
511 | bool compare( const String &s, int nLen ) const | 515 | bool compare( const String &s, int nLen ) const |
@@ -924,8 +928,9 @@ namespace Bu | |||
924 | */ | 928 | */ |
925 | void trimFront( long nAmnt ); | 929 | void trimFront( long nAmnt ); |
926 | 930 | ||
927 | // void trimBack( char c ); | ||
928 | void trimBack( long iAmnt ); | 931 | void trimBack( long iAmnt ); |
932 | |||
933 | Bu::String trimWhitespace() const; | ||
929 | 934 | ||
930 | iterator begin(); | 935 | iterator begin(); |
931 | 936 | ||
diff --git a/src/tests/archive.cpp b/src/tests/archive.cpp deleted file mode 100644 index c905007..0000000 --- a/src/tests/archive.cpp +++ /dev/null | |||
@@ -1,27 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/archive.h" | ||
9 | #include "bu/file.h" | ||
10 | #include "bu/string.h" | ||
11 | |||
12 | using namespace Bu; | ||
13 | |||
14 | int main() | ||
15 | { | ||
16 | File f("test.dat", File::WriteNew ); | ||
17 | Archive ar( f, Archive::save ); | ||
18 | |||
19 | Bu::String s("Hello there"); | ||
20 | ar << s; | ||
21 | |||
22 | ar.setProp("hi", 45 ); | ||
23 | printf("Hi: %d", ar.getProp<int>("hi") ); | ||
24 | |||
25 | return 0; | ||
26 | } | ||
27 | |||
diff --git a/src/tests/archive2.cpp b/src/tests/archive2.cpp deleted file mode 100644 index e8d3360..0000000 --- a/src/tests/archive2.cpp +++ /dev/null | |||
@@ -1,102 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/archive.h" | ||
9 | #include "bu/archival.h" | ||
10 | #include "bu/file.h" | ||
11 | |||
12 | int giId = 0; | ||
13 | |||
14 | class A : public Bu::Archival | ||
15 | { | ||
16 | public: | ||
17 | A() : | ||
18 | iId( giId++ ) | ||
19 | { | ||
20 | } | ||
21 | |||
22 | virtual ~A() | ||
23 | { | ||
24 | } | ||
25 | |||
26 | virtual void archive( Bu::ArchiveBase &ar ) | ||
27 | { | ||
28 | ar && iId; | ||
29 | } | ||
30 | |||
31 | int iId; | ||
32 | }; | ||
33 | |||
34 | class B : public Bu::Archival | ||
35 | { | ||
36 | public: | ||
37 | B() : | ||
38 | iId( giId++ ), | ||
39 | a1( new A ), | ||
40 | a2( new A ) | ||
41 | { | ||
42 | } | ||
43 | |||
44 | virtual ~B() | ||
45 | { | ||
46 | delete a1; | ||
47 | delete a2; | ||
48 | } | ||
49 | |||
50 | virtual void archive( Bu::ArchiveBase &ar ) | ||
51 | { | ||
52 | //ar && iId && a1 && a2; | ||
53 | ar << iId << a1 << a2; | ||
54 | } | ||
55 | |||
56 | int iId; | ||
57 | A *a1, *a2; | ||
58 | }; | ||
59 | |||
60 | class C : public Bu::Archival | ||
61 | { | ||
62 | public: | ||
63 | C() : | ||
64 | iId( giId++ ), | ||
65 | a( new A ), | ||
66 | b( new B ) | ||
67 | { | ||
68 | } | ||
69 | |||
70 | virtual ~C() | ||
71 | { | ||
72 | delete a; | ||
73 | delete b; | ||
74 | } | ||
75 | |||
76 | virtual void archive( Bu::ArchiveBase &ar ) | ||
77 | { | ||
78 | //ar && iId && a && b; | ||
79 | ar << iId; | ||
80 | ar << a << b; | ||
81 | } | ||
82 | |||
83 | int iId; | ||
84 | A *a; | ||
85 | B *b; | ||
86 | }; | ||
87 | |||
88 | void write() | ||
89 | { | ||
90 | C *c = new C; | ||
91 | |||
92 | Bu::File f( "test.archive", Bu::File::Write ); | ||
93 | Bu::Archive ar( f, Bu::Archive::save ); | ||
94 | ar << c; | ||
95 | } | ||
96 | |||
97 | int main() | ||
98 | { | ||
99 | write(); | ||
100 | |||
101 | } | ||
102 | |||
diff --git a/src/tests/atom.cpp b/src/tests/atom.cpp deleted file mode 100644 index 7808282..0000000 --- a/src/tests/atom.cpp +++ /dev/null | |||
@@ -1,32 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/atom.h" | ||
9 | #include <stdio.h> | ||
10 | #include <stdlib.h> | ||
11 | |||
12 | typedef struct bob | ||
13 | { | ||
14 | int a, b; | ||
15 | } bob; | ||
16 | int main() | ||
17 | { | ||
18 | Bu::Atom<int> aInt; | ||
19 | Bu::Atom<const char *> aStr; | ||
20 | Bu::Atom<bob> aBob; | ||
21 | |||
22 | aBob = bob(); | ||
23 | aBob->a = 5; | ||
24 | |||
25 | aStr.set("Hey there, dude"); | ||
26 | aInt.set( 55 ); | ||
27 | int me = aInt; | ||
28 | aInt = 12; | ||
29 | printf("%d, %d\n", aInt.get(), me ); | ||
30 | printf("%s\n", aStr.get() ); | ||
31 | } | ||
32 | |||
diff --git a/src/tests/buffer.cpp b/src/tests/buffer.cpp deleted file mode 100644 index f3f6f41..0000000 --- a/src/tests/buffer.cpp +++ /dev/null | |||
@@ -1,45 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/membuf.h" | ||
9 | #include "bu/buffer.h" | ||
10 | #include "bu/file.h" | ||
11 | |||
12 | using namespace Bu; | ||
13 | |||
14 | int main( int argc, char *argv[] ) | ||
15 | { | ||
16 | argc--,argv++; | ||
17 | if( argc == 0 ) | ||
18 | { | ||
19 | MemBuf mOut; | ||
20 | Buffer bOut( mOut, 10 ); | ||
21 | |||
22 | for( int j = 0; j < 4; j++ ) | ||
23 | bOut.write("hi ", 3 ); | ||
24 | |||
25 | printf("Preflush: \"%s\"\n", mOut.getString().getStr() ); | ||
26 | bOut.flush(); | ||
27 | |||
28 | printf("Final: \"%s\"\n", mOut.getString().getStr() ); | ||
29 | } | ||
30 | else | ||
31 | { | ||
32 | File fIn( *argv, File::Read ); | ||
33 | Buffer bIn( fIn, 10 ); | ||
34 | |||
35 | char buf[5]; | ||
36 | for( int j = 0; j < 5; j++ ) | ||
37 | { | ||
38 | buf[bIn.read( buf, 4 )] = '\0'; | ||
39 | printf("Four chars: \"%s\"\n", buf ); | ||
40 | } | ||
41 | } | ||
42 | |||
43 | return 0; | ||
44 | } | ||
45 | |||
diff --git a/src/tests/cache.cpp b/src/tests/cache.cpp deleted file mode 100644 index e9dbd86..0000000 --- a/src/tests/cache.cpp +++ /dev/null | |||
@@ -1,260 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include <stdio.h> | ||
9 | #include <stdlib.h> | ||
10 | #include <sys/stat.h> | ||
11 | #include <sys/types.h> | ||
12 | #include <errno.h> | ||
13 | #include <unistd.h> | ||
14 | |||
15 | #include "bu/cache.h" | ||
16 | #include "bu/file.h" | ||
17 | #include "bu/string.h" | ||
18 | #include "bu/cachecalc.h" | ||
19 | |||
20 | class Bob | ||
21 | { | ||
22 | public: | ||
23 | Bob() | ||
24 | { | ||
25 | TRACE(); | ||
26 | } | ||
27 | |||
28 | Bob( int i ) : | ||
29 | iInt( i ) | ||
30 | { | ||
31 | TRACE( i ); | ||
32 | } | ||
33 | |||
34 | virtual ~Bob() | ||
35 | { | ||
36 | TRACE(); | ||
37 | } | ||
38 | |||
39 | void setInt( int i ) | ||
40 | { | ||
41 | TRACE( i ); | ||
42 | iInt = i; | ||
43 | } | ||
44 | |||
45 | long getKey() const | ||
46 | { | ||
47 | TRACE( i ); | ||
48 | return iInt; | ||
49 | } | ||
50 | |||
51 | int getInt() | ||
52 | { | ||
53 | return iInt; | ||
54 | } | ||
55 | |||
56 | int iInt; | ||
57 | }; | ||
58 | |||
59 | namespace Bu { | ||
60 | template<> | ||
61 | void __tracer_format<Bob*>( Bob* const &c ) | ||
62 | { | ||
63 | printf("%08X=%d", (uint32_t)c, c->getInt() ); | ||
64 | } | ||
65 | } | ||
66 | |||
67 | class BobStore : public Bu::CacheStore<long, Bob> | ||
68 | { | ||
69 | public: | ||
70 | BobStore() : | ||
71 | cLastId( 0 ) | ||
72 | { | ||
73 | TRACE(); | ||
74 | if( access( "bobcache/last", R_OK|W_OK ) ) | ||
75 | { | ||
76 | mkdir("bobcache", 0755 ); | ||
77 | Bu::File f("bobcache/last", Bu::File::Write|Bu::File::Create ); | ||
78 | f.write("0", 1); | ||
79 | printf("Initializing cache: %s\n", strerror( errno ) ); | ||
80 | } | ||
81 | else | ||
82 | { | ||
83 | cLastId = readNum("bobcache/last"); | ||
84 | } | ||
85 | } | ||
86 | |||
87 | ~BobStore() | ||
88 | { | ||
89 | TRACE(); | ||
90 | writeNum("bobcache/last", cLastId ); | ||
91 | } | ||
92 | |||
93 | long readNum( const Bu::String &sFile ) | ||
94 | { | ||
95 | TRACE( sFile ); | ||
96 | Bu::File f( sFile, Bu::File::Read ); | ||
97 | char buf[80]; | ||
98 | buf[f.read( buf, 80 )] = '\0'; | ||
99 | return strtol( buf, NULL, 0 ); | ||
100 | } | ||
101 | |||
102 | void writeNum( const Bu::String &sFile, long num ) | ||
103 | { | ||
104 | TRACE( sFile, num ); | ||
105 | Bu::File f( sFile, | ||
106 | Bu::File::Write|Bu::File::Create|Bu::File::Truncate | ||
107 | ); | ||
108 | f.write( Bu::String("%1").arg( num ) ); | ||
109 | } | ||
110 | |||
111 | virtual void sync( Bob *, const long & ) | ||
112 | { | ||
113 | } | ||
114 | |||
115 | virtual void sync() | ||
116 | { | ||
117 | } | ||
118 | |||
119 | virtual bool has( const long & ) | ||
120 | { | ||
121 | return true; | ||
122 | } | ||
123 | |||
124 | virtual Bob *load( const long &key ) | ||
125 | { | ||
126 | TRACE( key ); | ||
127 | Bu::String sDest = Bu::String("bobcache/%1").arg( key ); | ||
128 | return new Bob( readNum( sDest ) ); | ||
129 | } | ||
130 | |||
131 | virtual void unload( Bob *pObj, const long &key ) | ||
132 | { | ||
133 | TRACE( pObj, key ); | ||
134 | Bu::String sDest = Bu::String("bobcache/%1").arg( key ); | ||
135 | writeNum( sDest, pObj->getInt() ); | ||
136 | delete pObj; | ||
137 | } | ||
138 | |||
139 | virtual long create( Bob *rSrc ) | ||
140 | { | ||
141 | TRACE( rSrc ); | ||
142 | long id = ++cLastId; | ||
143 | Bu::String sDest = Bu::String("bobcache/%1").arg( id ); | ||
144 | writeNum( sDest, rSrc->getInt() ); | ||
145 | return id; | ||
146 | } | ||
147 | |||
148 | virtual void destroy( Bob *pObj, const long &key ) | ||
149 | { | ||
150 | TRACE( pObj, key ); | ||
151 | Bu::String sDest = Bu::String("bobcache/%1").arg( key ); | ||
152 | if( !access( sDest.getStr(), F_OK ) ) | ||
153 | unlink( sDest.getStr() ); | ||
154 | delete pObj; | ||
155 | } | ||
156 | |||
157 | virtual void destroy( const long &key ) | ||
158 | { | ||
159 | TRACE( pObj, key ); | ||
160 | Bu::String sDest = Bu::String("bobcache/%1").arg( key ); | ||
161 | if( !access( sDest.getStr(), F_OK ) ) | ||
162 | unlink( sDest.getStr() ); | ||
163 | } | ||
164 | |||
165 | private: | ||
166 | long cLastId; | ||
167 | }; | ||
168 | |||
169 | class BobCalc : public Bu::CacheCalc<long, Bob> | ||
170 | { | ||
171 | public: | ||
172 | BobCalc() | ||
173 | { | ||
174 | } | ||
175 | |||
176 | virtual ~BobCalc() | ||
177 | { | ||
178 | } | ||
179 | |||
180 | virtual void onLoad( Bob *, const long & ) | ||
181 | { | ||
182 | } | ||
183 | |||
184 | virtual void onUnload( Bob *, const long & ) | ||
185 | { | ||
186 | } | ||
187 | |||
188 | virtual void onDestroy( Bob *, const long & ) | ||
189 | { | ||
190 | } | ||
191 | |||
192 | virtual void onDestroy( const long & ) | ||
193 | { | ||
194 | } | ||
195 | |||
196 | virtual bool shouldSync( Bob *, const long &, time_t ) | ||
197 | { | ||
198 | return false; | ||
199 | } | ||
200 | |||
201 | private: | ||
202 | |||
203 | }; | ||
204 | |||
205 | int main( int argc, char *argv[] ) | ||
206 | { | ||
207 | TRACE( argc, argv ); | ||
208 | typedef Bu::Cache<long, Bob> BobCache; | ||
209 | typedef BobCache::Ptr BobPtr; | ||
210 | |||
211 | if( argc < 3 ) | ||
212 | { | ||
213 | printf("Try: %s [crudl] [<id/value>]\n\n", argv[0] ); | ||
214 | return 0; | ||
215 | } | ||
216 | |||
217 | BobCache cBob( new BobCalc(), new BobStore() ); | ||
218 | switch( argv[1][0] ) | ||
219 | { | ||
220 | case 'c': | ||
221 | { | ||
222 | BobCache::Ptr pBob = cBob.insert( | ||
223 | new Bob( strtol( argv[2], NULL, 0 ) ) | ||
224 | ); | ||
225 | printf("Key = %ld\n", pBob.getKey() ); | ||
226 | } | ||
227 | return 0; | ||
228 | |||
229 | case 'r': | ||
230 | { | ||
231 | BobCache::Ptr pBob = cBob.get( strtol( argv[2], NULL, 0 ) ); | ||
232 | printf("Value = %d\n", pBob->getInt() ); | ||
233 | } | ||
234 | return 0; | ||
235 | |||
236 | case 'u': | ||
237 | { | ||
238 | BobCache::Ptr pBob = cBob.get( strtol( argv[2], NULL, 0 ) ); | ||
239 | pBob->setInt( strtol( argv[3], NULL, 0 ) ); | ||
240 | } | ||
241 | return 0; | ||
242 | |||
243 | case 'd': | ||
244 | { | ||
245 | cBob.erase( strtol( argv[2], NULL, 0 ) ); | ||
246 | } | ||
247 | return 0; | ||
248 | |||
249 | case 'l': | ||
250 | { | ||
251 | BobCache::Ptr pBob = cBob.getLazy( strtol( argv[2], NULL, 0 ) ); | ||
252 | printf("isBound: %s\n", pBob.isBound()?"yes":"no"); | ||
253 | printf("Value = %d\n", pBob->getInt() ); | ||
254 | printf("isBound: %s\n", pBob.isBound()?"yes":"no"); | ||
255 | } | ||
256 | return 0; | ||
257 | } | ||
258 | |||
259 | } | ||
260 | |||
diff --git a/src/tests/conduit.cpp b/src/tests/conduit.cpp deleted file mode 100644 index d8d9e03..0000000 --- a/src/tests/conduit.cpp +++ /dev/null | |||
@@ -1,56 +0,0 @@ | |||
1 | #include "bu/conduit.h" | ||
2 | #include "bu/sio.h" | ||
3 | #include "bu/ito.h" | ||
4 | |||
5 | using namespace Bu; | ||
6 | |||
7 | class Reader : public Bu::Ito | ||
8 | { | ||
9 | public: | ||
10 | Reader( Bu::Conduit &rCond ) : | ||
11 | rCond( rCond ) | ||
12 | { | ||
13 | } | ||
14 | |||
15 | virtual ~Reader() | ||
16 | { | ||
17 | } | ||
18 | |||
19 | protected: | ||
20 | virtual void run() | ||
21 | { | ||
22 | while( rCond.isOpen() ) | ||
23 | { | ||
24 | char buf[1025]; | ||
25 | |||
26 | sio << "Reading..." << sio.flush; | ||
27 | Bu::size iRead = rCond.read( buf, 1024 ); | ||
28 | buf[iRead] = '\0'; | ||
29 | sio << "got " << iRead << " >" << buf << "<" << sio.nl; | ||
30 | } | ||
31 | |||
32 | sio << "Conduit closed, exting thread." << sio.nl; | ||
33 | } | ||
34 | |||
35 | private: | ||
36 | Bu::Conduit &rCond; | ||
37 | }; | ||
38 | |||
39 | int main() | ||
40 | { | ||
41 | Conduit c; | ||
42 | Reader r( c ); | ||
43 | r.start(); | ||
44 | |||
45 | sleep( 3 ); | ||
46 | c.write("Hi there", 8 ); | ||
47 | sleep( 3 ); | ||
48 | c.write("Goodbye, soon.", 14 ); | ||
49 | sleep( 3 ); | ||
50 | c.write("...NOW!", 9 ); | ||
51 | c.close(); | ||
52 | sleep( 3 ); | ||
53 | |||
54 | return 0; | ||
55 | } | ||
56 | |||
diff --git a/src/tests/console.cpp b/src/tests/console.cpp deleted file mode 100644 index 670ff5b..0000000 --- a/src/tests/console.cpp +++ /dev/null | |||
@@ -1,43 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include <bu/sio.h> | ||
9 | using namespace Bu; | ||
10 | |||
11 | #include <iostream> | ||
12 | using namespace std; | ||
13 | |||
14 | typedef struct Counter | ||
15 | { | ||
16 | Counter() : i( 0 ) | ||
17 | { | ||
18 | } | ||
19 | |||
20 | int get() | ||
21 | { | ||
22 | i++; | ||
23 | return i-1; | ||
24 | } | ||
25 | |||
26 | int i; | ||
27 | } Counter; | ||
28 | |||
29 | template<typename a> | ||
30 | void runtest( a &out ) | ||
31 | { | ||
32 | Counter c; | ||
33 | out << c.get() << ", " << c.get() << ", " << c.get() << ", " << c.get() << ", " << c.get() << "\n"; | ||
34 | } | ||
35 | |||
36 | int main() | ||
37 | { | ||
38 | runtest( cout ); | ||
39 | runtest( sio ); | ||
40 | |||
41 | return 0; | ||
42 | } | ||
43 | |||
diff --git a/src/tests/cryptpass.cpp b/src/tests/cryptpass.cpp deleted file mode 100644 index d272344..0000000 --- a/src/tests/cryptpass.cpp +++ /dev/null | |||
@@ -1,25 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/crypt.h" | ||
9 | #include "bu/sio.h" | ||
10 | |||
11 | using namespace Bu; | ||
12 | |||
13 | int main( int argc, char *argv[] ) | ||
14 | { | ||
15 | if( argc == 1 ) | ||
16 | sio << "Syntax: " << argv[0] << " <password> [salt]" << sio.nl | ||
17 | << sio.nl; | ||
18 | else if( argc == 2 ) | ||
19 | sio << "Crypt1: >> " << cryptPass( argv[1] ) << " <<" << sio.nl; | ||
20 | else | ||
21 | sio << "Crypt2: >> " << cryptPass( argv[1], argv[2] ) << " <<" << sio.nl; | ||
22 | |||
23 | return 0; | ||
24 | } | ||
25 | |||
diff --git a/src/tests/csv.cpp b/src/tests/csv.cpp deleted file mode 100644 index 850fda8..0000000 --- a/src/tests/csv.cpp +++ /dev/null | |||
@@ -1,50 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/optparser.h" | ||
9 | #include "bu/file.h" | ||
10 | #include "bu/newline.h" | ||
11 | #include "bu/csvreader.h" | ||
12 | #include "bu/buffer.h" | ||
13 | #include "bu/sio.h" | ||
14 | |||
15 | using namespace Bu; | ||
16 | |||
17 | class Options : public OptParser | ||
18 | { | ||
19 | public: | ||
20 | Options( int argc, char *argv[] ) | ||
21 | { | ||
22 | addOption( slot( this, &Options::onRead ), 'r', "read", | ||
23 | "Read and display a csv file." ); | ||
24 | |||
25 | addHelpOption(); | ||
26 | |||
27 | parse( argc, argv ); | ||
28 | } | ||
29 | |||
30 | int onRead( StrArray aArgs ) | ||
31 | { | ||
32 | File fIn( aArgs[1], File::Read ); | ||
33 | NewLine nlIn( fIn ); | ||
34 | Buffer bIn( nlIn ); | ||
35 | CsvReader rCsv( bIn ); | ||
36 | while( !fIn.isEos() ) | ||
37 | { | ||
38 | sio << rCsv.readLine() << sio.nl; | ||
39 | } | ||
40 | sio << sio.nl; | ||
41 | return 1; | ||
42 | } | ||
43 | }; | ||
44 | |||
45 | int main( int argc, char *argv[] ) | ||
46 | { | ||
47 | Options opts( argc, argv ); | ||
48 | return 0; | ||
49 | } | ||
50 | |||
diff --git a/src/tests/daysinmonth.cpp b/src/tests/daysinmonth.cpp deleted file mode 100644 index 1e78eb3..0000000 --- a/src/tests/daysinmonth.cpp +++ /dev/null | |||
@@ -1,23 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/sio.h" | ||
9 | #include "bu/util.h" | ||
10 | |||
11 | using namespace Bu; | ||
12 | |||
13 | int main() | ||
14 | { | ||
15 | for( int j = 0; j < 12; j++ ) | ||
16 | { | ||
17 | sio << "2012-" << j << " = " | ||
18 | << getDaysInMonth( j, 2012 ) << sio.nl; | ||
19 | } | ||
20 | |||
21 | return 0; | ||
22 | } | ||
23 | |||
diff --git a/src/tests/fastcgi.cpp b/src/tests/fastcgi.cpp deleted file mode 100644 index 7447a6f..0000000 --- a/src/tests/fastcgi.cpp +++ /dev/null | |||
@@ -1,90 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/fastcgi.h" | ||
9 | |||
10 | #include <unistd.h> | ||
11 | |||
12 | class Cgi : public Bu::FastCgi | ||
13 | { | ||
14 | public: | ||
15 | Cgi() : | ||
16 | Bu::FastCgi::FastCgi() | ||
17 | { | ||
18 | } | ||
19 | |||
20 | Cgi( int iPort ) : | ||
21 | Bu::FastCgi::FastCgi( iPort ) | ||
22 | { | ||
23 | } | ||
24 | |||
25 | virtual ~Cgi() | ||
26 | { | ||
27 | } | ||
28 | |||
29 | virtual int onRequest( const StrHash &hParams, | ||
30 | const Bu::String &sStdIn, Bu::Stream &sStdOut, | ||
31 | Bu::Stream &/*sStdErr*/ ) | ||
32 | { | ||
33 | Bu::String sOut("Content-Type: text/html\r\n\r\n"); | ||
34 | sOut += "<html><body><h1>Environment:</h1><ul>"; | ||
35 | for( StrHash::const_iterator i = hParams.begin(); i; i++ ) | ||
36 | { | ||
37 | sOut += "<li>" + i.getKey() + " = " + | ||
38 | i.getValue() + "</li>"; | ||
39 | } | ||
40 | sOut += "</ul>"; | ||
41 | char buf[2048]; | ||
42 | sOut += "<h1>Cwd:</h1><ul><li>"; | ||
43 | sOut += getcwd( buf, 2048 ); | ||
44 | sOut += "</li></ul>"; | ||
45 | sOut += "<h1>Stdin:</h1>"; | ||
46 | sOut += Bu::String("%1 bytes<pre>").arg( sStdIn.getSize() ); | ||
47 | Bu::String sL, sR; | ||
48 | for( Bu::String::const_iterator i = sStdIn.begin(); | ||
49 | i; i++ ) | ||
50 | { | ||
51 | sL += Bu::String("%1").arg( | ||
52 | (unsigned int)((unsigned char)*i), Bu::Fmt::hex().width(2).fill('0') ); | ||
53 | if( *i < 27 ) | ||
54 | sR += ". "; | ||
55 | else | ||
56 | sR += Bu::String("&#%1; ").arg( | ||
57 | (unsigned int)((unsigned char)*i) ); | ||
58 | if( sL.getSize()/3 == 8 ) | ||
59 | { | ||
60 | sOut += sL + " | " + sR + "\n"; | ||
61 | sL = sR = ""; | ||
62 | } | ||
63 | } | ||
64 | if( sL != "" ) | ||
65 | { | ||
66 | while( sL.getSize()/3 < 8 ) | ||
67 | sL += " "; | ||
68 | sOut += sL + " | " + sR + "\n"; | ||
69 | } | ||
70 | sOut += "</pre><hr/><pre>"; | ||
71 | sOut += sStdIn; | ||
72 | sOut += "</pre>"; | ||
73 | sOut += "<form method=\"post\" enctype=\"multipart/form-data\"><textarea name=\"bob\"></textarea><br /><input type=\"file\" name=\"somefile\" /><br /><input type=\"submit\" name=\"yeah\" value=\"try it\" /></form>"; | ||
74 | sOut += "</body></html>"; | ||
75 | |||
76 | sStdOut.write( sOut ); | ||
77 | |||
78 | return 0; | ||
79 | } | ||
80 | }; | ||
81 | |||
82 | int main() | ||
83 | { | ||
84 | Cgi c( 8789 ); | ||
85 | |||
86 | c.run(); | ||
87 | |||
88 | return 0; | ||
89 | } | ||
90 | |||
diff --git a/src/tests/formula.cpp b/src/tests/formula.cpp deleted file mode 100644 index a90ddaf..0000000 --- a/src/tests/formula.cpp +++ /dev/null | |||
@@ -1,56 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/formula.h" | ||
9 | #include <math.h> | ||
10 | |||
11 | int main( int argc, char *argv[] ) | ||
12 | { | ||
13 | if( argc < 2 ) | ||
14 | { | ||
15 | printf("usage: %s <formula>\n", argv[0] ); | ||
16 | return -1; | ||
17 | } | ||
18 | Bu::Formula<uint32_t> uForm; | ||
19 | Bu::Formula<double> dForm; | ||
20 | |||
21 | class DblCeilFunc : public Bu::Formula<double>::Func | ||
22 | { | ||
23 | public: | ||
24 | virtual double operator()( double x ) | ||
25 | { | ||
26 | return ceil( x ); | ||
27 | } | ||
28 | }; | ||
29 | |||
30 | dForm.hFunc.insert( "ceil", new DblCeilFunc() ); | ||
31 | |||
32 | class IntCeilFunc : public Bu::Formula<uint32_t>::Func | ||
33 | { | ||
34 | public: | ||
35 | virtual uint32_t operator()( uint32_t x ) | ||
36 | { | ||
37 | return x; | ||
38 | } | ||
39 | }; | ||
40 | |||
41 | uForm.hFunc.insert( "ceil", new IntCeilFunc() ); | ||
42 | |||
43 | uForm.hVars.insert("x", 10 ); | ||
44 | dForm.hVars.insert("x", 10.00 ); | ||
45 | uForm.hVars.insert("y", 10 ); | ||
46 | dForm.hVars.insert("y", 10.00 ); | ||
47 | |||
48 | for( int j = 1; j < argc; j++ ) | ||
49 | { | ||
50 | printf("u: %s = %u\n", argv[j], uForm.run( argv[j] ) ); | ||
51 | printf("d: %s = %f\n", argv[j], dForm.run( argv[j] ) ); | ||
52 | } | ||
53 | |||
54 | return 0; | ||
55 | } | ||
56 | |||
diff --git a/src/tests/fstratsptr.cpp b/src/tests/fstratsptr.cpp deleted file mode 100644 index 5053dd1..0000000 --- a/src/tests/fstratsptr.cpp +++ /dev/null | |||
@@ -1,53 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/string.h" | ||
9 | #include "bu/atom.h" | ||
10 | #include "bu/sptr.h" | ||
11 | |||
12 | class Person | ||
13 | { | ||
14 | public: | ||
15 | Person(){}; | ||
16 | virtual ~Person(){}; | ||
17 | |||
18 | Bu::Atom<Bu::String> sFirstName; | ||
19 | Bu::Atom<Bu::String> sLastName; | ||
20 | }; | ||
21 | |||
22 | typedef Bu::SPtr<Person> PersonPtr; | ||
23 | |||
24 | void Swap(PersonPtr one, PersonPtr two) | ||
25 | { | ||
26 | PersonPtr three(new Person); | ||
27 | three->sFirstName = one->sFirstName; | ||
28 | three->sLastName = two->sLastName; | ||
29 | |||
30 | printf( | ||
31 | "%s %s\n", | ||
32 | three->sFirstName->getStr(), | ||
33 | three->sLastName->getStr() ); | ||
34 | } | ||
35 | |||
36 | int main() | ||
37 | { | ||
38 | /* PersonPtr one(new Person); | ||
39 | PersonPtr two(new Person); | ||
40 | one->sFirstName = "Bob"; | ||
41 | one->sLastName = "Smith"; | ||
42 | two->sFirstName = "Fred"; | ||
43 | two->sLastName = "Carpenter"; | ||
44 | |||
45 | Swap(one, two); | ||
46 | */ | ||
47 | |||
48 | Bu::Atom<Bu::String> sOne, sTwo; | ||
49 | sOne = "Hello"; | ||
50 | sTwo = sOne; | ||
51 | |||
52 | return 0; | ||
53 | } | ||
diff --git a/src/tests/fstrstd.cpp b/src/tests/fstrstd.cpp deleted file mode 100644 index b2fed8a..0000000 --- a/src/tests/fstrstd.cpp +++ /dev/null | |||
@@ -1,16 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include <iostream> | ||
9 | #include "bu/string.h" | ||
10 | |||
11 | int main() | ||
12 | { | ||
13 | Bu::String s("Hey there, dude.\n"); | ||
14 | |||
15 | // std::cout << s << 5; | ||
16 | } | ||
diff --git a/src/tests/hash.cpp b/src/tests/hash.cpp deleted file mode 100644 index 7cefb79..0000000 --- a/src/tests/hash.cpp +++ /dev/null | |||
@@ -1,31 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/hash.h" | ||
9 | #include "bu/sptr.h" | ||
10 | |||
11 | typedef struct Bob | ||
12 | { | ||
13 | int nID; | ||
14 | } Bob; | ||
15 | |||
16 | int main() | ||
17 | { | ||
18 | Bu::Hash<int, Bu::SPtr<const Bob> > lb; | ||
19 | for( int j = 0; j < 10; j++ ) | ||
20 | { | ||
21 | Bob *b = new Bob; | ||
22 | b->nID = j; | ||
23 | lb.insert( j, b ); | ||
24 | } | ||
25 | |||
26 | for( int j = 0; j < 10; j++ ) | ||
27 | { | ||
28 | printf("%d\n", lb[j].getValue()->nID ); | ||
29 | } | ||
30 | } | ||
31 | |||
diff --git a/src/tests/hash2.cpp b/src/tests/hash2.cpp deleted file mode 100644 index 55bb4c9..0000000 --- a/src/tests/hash2.cpp +++ /dev/null | |||
@@ -1,35 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include <bu/string.h> | ||
9 | #include <bu/hash.h> | ||
10 | |||
11 | int main() | ||
12 | { | ||
13 | Bu::Hash<Bu::String, int> hCmd; | ||
14 | |||
15 | hCmd.insert("help", 5 ); | ||
16 | hCmd.insert("exit", 5 ); | ||
17 | hCmd.insert("getkey", 5 ); | ||
18 | hCmd.insert("setcrypt", 5 ); | ||
19 | hCmd.insert("user", 5 ); | ||
20 | hCmd.insert("pass", 5 ); | ||
21 | hCmd.erase("getkey"); | ||
22 | hCmd.erase("setcrypt"); | ||
23 | hCmd.insert("user", 5 ); | ||
24 | hCmd.insert("pass", 5 ); | ||
25 | hCmd.erase("pass"); | ||
26 | hCmd.erase("user"); | ||
27 | hCmd.insert("acl", 5 ); | ||
28 | hCmd.insert("owner", 5 ); | ||
29 | hCmd.insert("operator", 5 ); | ||
30 | hCmd.insert("admin", 5 ); | ||
31 | hCmd.insert("monitor", 5 ); | ||
32 | hCmd.insert("shutdown", 5 ); | ||
33 | |||
34 | return 0; | ||
35 | } | ||
diff --git a/src/tests/heap.cpp b/src/tests/heap.cpp deleted file mode 100644 index 520a57f..0000000 --- a/src/tests/heap.cpp +++ /dev/null | |||
@@ -1,120 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include <stdlib.h> | ||
9 | #include <stdio.h> | ||
10 | |||
11 | #include "bu/formatter.h" | ||
12 | #include "bu/heap.h" | ||
13 | #include "bu/string.h" | ||
14 | #include "bu/file.h" | ||
15 | |||
16 | typedef struct num | ||
17 | { | ||
18 | num( int iNum, int iOrder ) : iNum( iNum ), iOrder( iOrder ) | ||
19 | { | ||
20 | } | ||
21 | |||
22 | num( const num &src ) : iNum( src.iNum ), iOrder( src.iOrder ) | ||
23 | { | ||
24 | } | ||
25 | |||
26 | int iNum; | ||
27 | int iOrder; | ||
28 | |||
29 | bool operator<( const num &oth ) const | ||
30 | { | ||
31 | if( iNum == oth.iNum ) | ||
32 | return iOrder < oth.iOrder; | ||
33 | return iNum < oth.iNum; | ||
34 | } | ||
35 | bool operator>( const num &oth ) const | ||
36 | { | ||
37 | return iNum > oth.iNum; | ||
38 | } | ||
39 | } num; | ||
40 | |||
41 | void printHeap( Bu::Heap<Bu::String> &h, int j ) | ||
42 | { | ||
43 | // return; | ||
44 | Bu::String sFName = Bu::String("graph-step-%1.dot").arg( j, Bu::Fmt().width(2).fill('0') ); | ||
45 | Bu::File fOut( sFName, Bu::File::WriteNew ); | ||
46 | Bu::Formatter f( fOut ); | ||
47 | f << "Graph step: " << j << ", total size: " << h.getSize() << f.nl; | ||
48 | for( Bu::Heap<Bu::String>::iterator i = h.begin(); i; i++ ) | ||
49 | { | ||
50 | f << *i << f.nl; | ||
51 | } | ||
52 | f << f.nl; | ||
53 | } | ||
54 | |||
55 | int main() | ||
56 | { | ||
57 | /* | ||
58 | Bu::Heap<num> hNum; | ||
59 | |||
60 | for( int j = 0; j < 30; j++ ) | ||
61 | { | ||
62 | int r = rand()%10; | ||
63 | printf("Pushing: %d, top: ", r ); | ||
64 | hNum.enqueue( num( r, j ) ); | ||
65 | printf("%d\n", hNum.peek().iNum ); | ||
66 | } | ||
67 | |||
68 | while( !hNum.isEmpty() ) | ||
69 | { | ||
70 | printf("(%d:%d) ", hNum.peek().iOrder, hNum.peek().iNum ); | ||
71 | hNum.dequeue(); | ||
72 | } | ||
73 | printf("\n"); | ||
74 | */ | ||
75 | Bu::Heap<Bu::String> hStr; | ||
76 | int j = 0; | ||
77 | |||
78 | hStr.enqueue("George"); | ||
79 | printHeap( hStr, j++ ); | ||
80 | hStr.enqueue("George"); | ||
81 | printHeap( hStr, j++ ); | ||
82 | hStr.enqueue("Sam"); | ||
83 | printHeap( hStr, j++ ); | ||
84 | hStr.enqueue("Abby"); | ||
85 | printHeap( hStr, j++ ); | ||
86 | hStr.enqueue("Zorro"); | ||
87 | printHeap( hStr, j++ ); | ||
88 | hStr.enqueue("Brianna"); | ||
89 | printHeap( hStr, j++ ); | ||
90 | hStr.enqueue("Kate"); | ||
91 | printHeap( hStr, j++ ); | ||
92 | hStr.enqueue("Soggy"); | ||
93 | printHeap( hStr, j++ ); | ||
94 | |||
95 | while( !hStr.isEmpty() ) | ||
96 | { | ||
97 | printf("\"%s\" ", hStr.dequeue().getStr() ); | ||
98 | printHeap( hStr, j++ ); | ||
99 | } | ||
100 | printf("\n"); | ||
101 | |||
102 | Bu::List<Bu::String> lStr; | ||
103 | |||
104 | lStr.insertSorted("George"); | ||
105 | lStr.insertSorted("George"); | ||
106 | lStr.insertSorted("Sam"); | ||
107 | lStr.insertSorted("Abby"); | ||
108 | lStr.insertSorted("Zorro"); | ||
109 | lStr.insertSorted("Brianna"); | ||
110 | lStr.insertSorted("Kate"); | ||
111 | lStr.insertSorted("Soggy"); | ||
112 | for( Bu::List<Bu::String>::iterator i = lStr.begin(); i; i++ ) | ||
113 | { | ||
114 | printf("\"%s\" ", (*i).getStr() ); | ||
115 | } | ||
116 | printf("\n"); | ||
117 | |||
118 | return 0; | ||
119 | } | ||
120 | |||
diff --git a/src/tests/itoheap.cpp b/src/tests/itoheap.cpp deleted file mode 100644 index ec06b90..0000000 --- a/src/tests/itoheap.cpp +++ /dev/null | |||
@@ -1,70 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include <stdio.h> | ||
9 | #include <stdlib.h> | ||
10 | #include <unistd.h> | ||
11 | |||
12 | #include "bu/itoheap.h" | ||
13 | #include "bu/ito.h" | ||
14 | |||
15 | class Consumer : public Bu::Ito | ||
16 | { | ||
17 | public: | ||
18 | Consumer() | ||
19 | { | ||
20 | } | ||
21 | |||
22 | virtual ~Consumer() | ||
23 | { | ||
24 | } | ||
25 | |||
26 | void run() | ||
27 | { | ||
28 | for( int j = 0; j < 10; j++ ) | ||
29 | { | ||
30 | printf("Trying to read [%d].\n", j ); | ||
31 | |||
32 | try | ||
33 | { | ||
34 | int iNum = hInt.dequeue( 0, 500000 ); | ||
35 | printf("Read %d\n", iNum ); | ||
36 | } | ||
37 | catch( Bu::HeapException &e ) | ||
38 | { | ||
39 | printf("Nothing yet...\n"); | ||
40 | } | ||
41 | } | ||
42 | } | ||
43 | |||
44 | Bu::ItoHeap<int> hInt; | ||
45 | }; | ||
46 | |||
47 | |||
48 | int main() | ||
49 | { | ||
50 | Consumer c; | ||
51 | |||
52 | for( int j = 0; j < 3; j++ ) | ||
53 | { | ||
54 | int iNum = rand()%10; | ||
55 | printf("Enqueuing %d.\n", iNum ); | ||
56 | c.hInt.enqueue( iNum ); | ||
57 | } | ||
58 | |||
59 | printf("Sarting consumer.\n"); | ||
60 | c.start(); | ||
61 | |||
62 | for( int j = 0; j < 5; j++ ) | ||
63 | { | ||
64 | sleep( 1 ); | ||
65 | int iNum = rand()%10; | ||
66 | printf("Enqueuing %d.\n", iNum ); | ||
67 | c.hInt.enqueue( iNum ); | ||
68 | } | ||
69 | } | ||
70 | |||
diff --git a/src/tests/itoqueue1.cpp b/src/tests/itoqueue1.cpp deleted file mode 100644 index 27cb93c..0000000 --- a/src/tests/itoqueue1.cpp +++ /dev/null | |||
@@ -1,115 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include <string> | ||
9 | #include "bu/ito.h" | ||
10 | #include "bu/itoqueue.h" | ||
11 | #include <stdlib.h> | ||
12 | #include <stdio.h> | ||
13 | |||
14 | class Reader : public Bu::Ito | ||
15 | { | ||
16 | public: | ||
17 | Reader( Bu::ItoQueue<std::string *> &q, int id ) : | ||
18 | q( q ), | ||
19 | id( id ) | ||
20 | { | ||
21 | } | ||
22 | |||
23 | void run() | ||
24 | { | ||
25 | for( int i = 0; i < 10; i++ ) | ||
26 | { | ||
27 | std::string *pStr = q.dequeue( true ); | ||
28 | if( pStr == NULL ) | ||
29 | { | ||
30 | printf("Null received...\n"); | ||
31 | } | ||
32 | else | ||
33 | { | ||
34 | printf("[%d] read: %s\n", id, pStr->c_str() ); | ||
35 | delete pStr; | ||
36 | } | ||
37 | usleep( (int)(((double)rand())/((double)RAND_MAX)*2000000.0) ); | ||
38 | } | ||
39 | } | ||
40 | |||
41 | private: | ||
42 | Bu::ItoQueue<std::string *> &q; | ||
43 | int id; | ||
44 | }; | ||
45 | |||
46 | class Writer : public Bu::Ito | ||
47 | { | ||
48 | public: | ||
49 | Writer( Bu::ItoQueue<std::string *> &q, int id, const char *strbase ) : | ||
50 | q( q ), | ||
51 | strbase( strbase ), | ||
52 | id( id ) | ||
53 | { | ||
54 | } | ||
55 | |||
56 | void run() | ||
57 | { | ||
58 | for( int i = 0; i < 11; i++ ) | ||
59 | { | ||
60 | usleep( (int)(((double)rand())/((double)RAND_MAX)*2000000.0) ); | ||
61 | q.enqueue( new std::string( strbase ) ); | ||
62 | printf("[%d] write: %s\n", id, strbase ); | ||
63 | } | ||
64 | } | ||
65 | |||
66 | private: | ||
67 | Bu::ItoQueue<std::string *> &q; | ||
68 | const char *strbase; | ||
69 | int id; | ||
70 | }; | ||
71 | |||
72 | int main() | ||
73 | { | ||
74 | Writer *wr[5]; | ||
75 | Reader *rd[5]; | ||
76 | const char bob[][7]={ | ||
77 | {"Test 1"}, | ||
78 | {"Test 2"}, | ||
79 | {"Test 3"}, | ||
80 | {"Test 4"}, | ||
81 | {"Test 5"} | ||
82 | }; | ||
83 | |||
84 | Bu::ItoQueue<std::string *> q; | ||
85 | |||
86 | for( int j = 0; j < 5; j++ ) | ||
87 | { | ||
88 | wr[j] = new Writer( q, j, bob[j] ); | ||
89 | rd[j] = new Reader( q, j ); | ||
90 | } | ||
91 | |||
92 | for( int j = 0; j < 5; j++ ) | ||
93 | { | ||
94 | rd[j]->start(); | ||
95 | } | ||
96 | |||
97 | for( int j = 0; j < 5; j++ ) | ||
98 | { | ||
99 | wr[j]->start(); | ||
100 | } | ||
101 | |||
102 | for( int j = 0; j < 5; j++ ) | ||
103 | { | ||
104 | rd[j]->join(); | ||
105 | } | ||
106 | |||
107 | for( int j = 0; j < 5; j++ ) | ||
108 | { | ||
109 | delete wr[j]; | ||
110 | delete rd[j]; | ||
111 | } | ||
112 | |||
113 | return 0; | ||
114 | } | ||
115 | |||
diff --git a/src/tests/itoqueue2.cpp b/src/tests/itoqueue2.cpp deleted file mode 100644 index 10bc566..0000000 --- a/src/tests/itoqueue2.cpp +++ /dev/null | |||
@@ -1,87 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include <string> | ||
9 | #include "bu/ito.h" | ||
10 | #include "bu/itoqueue.h" | ||
11 | #include <errno.h> | ||
12 | #include <stdio.h> | ||
13 | |||
14 | class Reader : public Bu::Ito | ||
15 | { | ||
16 | public: | ||
17 | Reader( Bu::ItoQueue<std::string *> &q, int id ) : | ||
18 | q( q ), | ||
19 | id( id ) | ||
20 | { | ||
21 | } | ||
22 | |||
23 | void run() | ||
24 | { | ||
25 | for( int i = 0; i < 10; i++ ) | ||
26 | { | ||
27 | std::string *pStr = q.dequeue( 0, 500000 ); | ||
28 | if( pStr == NULL ) | ||
29 | { | ||
30 | printf("Null received...\n"); | ||
31 | i--; | ||
32 | } | ||
33 | else | ||
34 | { | ||
35 | printf("[%d] read: %s\n", id, pStr->c_str() ); | ||
36 | delete pStr; | ||
37 | } | ||
38 | } | ||
39 | } | ||
40 | |||
41 | private: | ||
42 | Bu::ItoQueue<std::string *> &q; | ||
43 | int id; | ||
44 | }; | ||
45 | |||
46 | class Writer : public Bu::Ito | ||
47 | { | ||
48 | public: | ||
49 | Writer( Bu::ItoQueue<std::string *> &q, int id, const char *strbase ) : | ||
50 | q( q ), | ||
51 | strbase( strbase ), | ||
52 | id( id ) | ||
53 | { | ||
54 | } | ||
55 | |||
56 | void run() | ||
57 | { | ||
58 | for( int i = 0; i < 11; i++ ) | ||
59 | { | ||
60 | sleep( 2 ); | ||
61 | printf("[%d] write: %s\n", id, strbase ); | ||
62 | q.enqueue( new std::string( strbase ) ); | ||
63 | } | ||
64 | } | ||
65 | |||
66 | private: | ||
67 | Bu::ItoQueue<std::string *> &q; | ||
68 | const char *strbase; | ||
69 | int id; | ||
70 | }; | ||
71 | |||
72 | int main() | ||
73 | { | ||
74 | printf("ETIMEDOUT: %d\n", ETIMEDOUT ); | ||
75 | Bu::ItoQueue<std::string *> q; | ||
76 | Writer wr( q, 0, "writer" ); | ||
77 | Reader rd( q, 0 ); | ||
78 | |||
79 | rd.start(); | ||
80 | wr.start(); | ||
81 | |||
82 | rd.join(); | ||
83 | wr.join(); | ||
84 | |||
85 | return 0; | ||
86 | } | ||
87 | |||
diff --git a/src/tests/itoserver.cpp b/src/tests/itoserver.cpp deleted file mode 100644 index 48ef527..0000000 --- a/src/tests/itoserver.cpp +++ /dev/null | |||
@@ -1,80 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/itoserver.h" | ||
9 | #include "bu/protocol.h" | ||
10 | #include "bu/client.h" | ||
11 | |||
12 | #define BU_TRACE | ||
13 | #include "bu/trace.h" | ||
14 | |||
15 | class ProtocolEcho : public Bu::Protocol | ||
16 | { | ||
17 | public: | ||
18 | ProtocolEcho() | ||
19 | { | ||
20 | TRACE(); | ||
21 | } | ||
22 | virtual ~ProtocolEcho() | ||
23 | { | ||
24 | TRACE(); | ||
25 | } | ||
26 | |||
27 | virtual void onNewConnection( Bu::Client * ) | ||
28 | { | ||
29 | TRACE(); | ||
30 | // Huh... | ||
31 | } | ||
32 | |||
33 | virtual void onNewData( Bu::Client *pClient ) | ||
34 | { | ||
35 | TRACE(); | ||
36 | char buf[1024]; | ||
37 | while( pClient->hasInput() ) | ||
38 | { | ||
39 | int iAmnt = pClient->read( buf, 1024 ); | ||
40 | pClient->write( buf, iAmnt ); | ||
41 | } | ||
42 | } | ||
43 | }; | ||
44 | |||
45 | class TestServer : public Bu::ItoServer | ||
46 | { | ||
47 | public: | ||
48 | TestServer() | ||
49 | { | ||
50 | TRACE(); | ||
51 | } | ||
52 | virtual ~TestServer() | ||
53 | { | ||
54 | TRACE(); | ||
55 | } | ||
56 | |||
57 | virtual void onNewConnection( Bu::Client *pClient, int ) | ||
58 | { | ||
59 | TRACE(); | ||
60 | pClient->setProtocol( new ProtocolEcho() ); | ||
61 | } | ||
62 | |||
63 | virtual void onClosedConnection( Bu::Client *pClient ) | ||
64 | { | ||
65 | TRACE(); | ||
66 | delete pClient->getProtocol(); | ||
67 | } | ||
68 | }; | ||
69 | |||
70 | int main() | ||
71 | { | ||
72 | TRACE(); | ||
73 | |||
74 | TestServer ts; | ||
75 | |||
76 | ts.addPort( 5555 ); | ||
77 | ts.start(); | ||
78 | ts.join(); | ||
79 | } | ||
80 | |||
diff --git a/src/tests/list.cpp b/src/tests/list.cpp deleted file mode 100644 index aa3d32d..0000000 --- a/src/tests/list.cpp +++ /dev/null | |||
@@ -1,77 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/list.h" | ||
9 | #include <list> | ||
10 | |||
11 | typedef struct Bob | ||
12 | { | ||
13 | int nID; | ||
14 | } Bob; | ||
15 | |||
16 | int main() | ||
17 | { | ||
18 | Bu::List<int> l; | ||
19 | |||
20 | l.append( 0 ); | ||
21 | |||
22 | for( int j = 3; j <= 21; j += 3 ) | ||
23 | { | ||
24 | l.append( j ); | ||
25 | l.prepend( -j ); | ||
26 | } | ||
27 | |||
28 | { | ||
29 | Bu::List<int>::iterator i = l.begin(); | ||
30 | Bu::List<int>::iterator j = i; | ||
31 | int a, b; | ||
32 | a = *j; | ||
33 | printf("end: %s\n", (j != l.end())?"no":"yes"); | ||
34 | j--; | ||
35 | printf("end: %s\n", (j != l.end())?"no":"yes"); | ||
36 | j++; | ||
37 | printf("end: %s\n", (j != l.end())?"no":"yes"); | ||
38 | i = j; | ||
39 | b = *i; | ||
40 | printf("%d -> %d\n", a, b ); | ||
41 | } | ||
42 | |||
43 | for( Bu::List<int>::iterator i = l.begin(); i != l.end(); i++ ) | ||
44 | { | ||
45 | printf("%d ", *i ); | ||
46 | } | ||
47 | printf("\n"); | ||
48 | for( Bu::List<int>::iterator i = l.begin(); i != l.end(); i++ ) | ||
49 | { | ||
50 | Bu::List<int>::iterator j = i; j--; | ||
51 | l.erase( i ); | ||
52 | i = j; | ||
53 | if( i != l.end() ) | ||
54 | printf("!%d ", *i ); | ||
55 | } | ||
56 | |||
57 | printf("\n\n"); | ||
58 | |||
59 | Bu::List<Bob> lb; | ||
60 | for( int j = 0; j < 10; j++ ) | ||
61 | { | ||
62 | Bob b; | ||
63 | b.nID = j; | ||
64 | lb.append( b ); | ||
65 | } | ||
66 | |||
67 | const Bu::List<Bob> rb = lb; | ||
68 | |||
69 | for( Bu::List<Bob>::const_iterator i = rb.begin(); i != rb.end(); i++ ) | ||
70 | { | ||
71 | //i->nID += 2; | ||
72 | //(*i).nID = 4; | ||
73 | printf("%d ", i->nID ); | ||
74 | } | ||
75 | printf("\n\n"); | ||
76 | } | ||
77 | |||
diff --git a/src/tests/list2.cpp b/src/tests/list2.cpp deleted file mode 100644 index 567370e..0000000 --- a/src/tests/list2.cpp +++ /dev/null | |||
@@ -1,26 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include <bu/list.h> | ||
9 | #include <bu/sio.h> | ||
10 | |||
11 | using namespace Bu; | ||
12 | |||
13 | int main() | ||
14 | { | ||
15 | List<int64_t> lInt; | ||
16 | |||
17 | lInt.append( 512 ); | ||
18 | lInt.append( 1024 ); | ||
19 | lInt.append( 4096 ); | ||
20 | lInt.append( 12 ); | ||
21 | lInt.erase( 12 ); | ||
22 | lInt.append( 12 ); | ||
23 | lInt.erase( 12 ); | ||
24 | lInt.append( 12 ); | ||
25 | } | ||
26 | |||
diff --git a/src/tests/listsort.cpp b/src/tests/listsort.cpp deleted file mode 100644 index 4873a05..0000000 --- a/src/tests/listsort.cpp +++ /dev/null | |||
@@ -1,79 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include <bu/list.h> | ||
9 | #include <bu/sio.h> | ||
10 | #include <bu/string.h> | ||
11 | |||
12 | using namespace Bu; | ||
13 | |||
14 | int main() | ||
15 | { | ||
16 | /* | ||
17 | List<int> il; | ||
18 | il.append( 5 ); | ||
19 | il.append( 12 ); | ||
20 | il.append( 0 ); | ||
21 | il.append( 7 ); | ||
22 | il.append( 3 ); | ||
23 | il.append( 5 ); | ||
24 | Bu::__basicLTCmp<int> cmp; | ||
25 | il.sortI( cmp ); | ||
26 | */ | ||
27 | |||
28 | String a("Soggy"), b("Sam"); | ||
29 | |||
30 | if( a < b ) | ||
31 | { | ||
32 | sio << "Bad" << sio.nl; | ||
33 | } | ||
34 | else | ||
35 | { | ||
36 | sio << "Good" << sio.nl; | ||
37 | } | ||
38 | |||
39 | typedef List<String> StrList; | ||
40 | |||
41 | StrList lNames; | ||
42 | |||
43 | lNames.append("George"); | ||
44 | lNames.append("Sam"); | ||
45 | lNames.append("Abby"); | ||
46 | lNames.append("Zorro"); | ||
47 | lNames.append("Brianna"); | ||
48 | lNames.append("Kate"); | ||
49 | lNames.append("Soggy"); | ||
50 | |||
51 | sio << "Names: " << lNames << sio.nl; | ||
52 | lNames.sort(); | ||
53 | |||
54 | sio << "Names: " << lNames << sio.nl; | ||
55 | |||
56 | StrList lNames2; | ||
57 | |||
58 | lNames2.insertSorted("George"); | ||
59 | lNames2.insertSorted("Sam"); | ||
60 | lNames2.insertSorted("Abby"); | ||
61 | lNames2.insertSorted("Zorro"); | ||
62 | lNames2.insertSorted("Brianna"); | ||
63 | lNames2.insertSorted("Kate"); | ||
64 | lNames2.insertSorted("Soggy"); | ||
65 | |||
66 | sio << "Names: " << lNames2 << sio.nl; | ||
67 | |||
68 | if( lNames == lNames2 ) | ||
69 | { | ||
70 | sio << "They're the same." << sio.nl; | ||
71 | } | ||
72 | else | ||
73 | { | ||
74 | sio << "They're different." << sio.nl; | ||
75 | } | ||
76 | |||
77 | return 0; | ||
78 | } | ||
79 | |||
diff --git a/src/tests/logger.cpp b/src/tests/logger.cpp deleted file mode 100644 index e97193c..0000000 --- a/src/tests/logger.cpp +++ /dev/null | |||
@@ -1,37 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/logger.h" | ||
9 | #include <errno.h> | ||
10 | #include <stdlib.h> | ||
11 | |||
12 | class Thing | ||
13 | { | ||
14 | public: | ||
15 | Thing() | ||
16 | { | ||
17 | lineLog( 2, "Want a thing?"); | ||
18 | } | ||
19 | |||
20 | void go( int ) | ||
21 | { | ||
22 | lineLog( 1, "GO!!!!"); | ||
23 | } | ||
24 | }; | ||
25 | |||
26 | int main() | ||
27 | { | ||
28 | setLogLevel( 4 ); | ||
29 | setLogFormat("%L: %y-%02m-%02d %h:%02M:%02s %f:%l:%F: %t"); | ||
30 | lineLog( 5, "Hey, error: %s", strerror( errno ) ); | ||
31 | |||
32 | logHexDump( 5, "This is a test of the hex-dump facility", 16, "Random stuff"); | ||
33 | |||
34 | Thing gh; | ||
35 | gh.go( 6 ); | ||
36 | } | ||
37 | |||
diff --git a/src/tests/md5.cpp b/src/tests/md5.cpp deleted file mode 100644 index a32f669..0000000 --- a/src/tests/md5.cpp +++ /dev/null | |||
@@ -1,34 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/sio.h" | ||
9 | #include "bu/file.h" | ||
10 | #include "bu/md5.h" | ||
11 | |||
12 | using Bu::sio; | ||
13 | |||
14 | int main( int argc, char *argv[] ) | ||
15 | { | ||
16 | argv++, argc--; | ||
17 | for(; *argv; argv++ ) | ||
18 | { | ||
19 | Bu::File fIn( *argv, Bu::File::Read ); | ||
20 | Bu::Md5 m; | ||
21 | |||
22 | char buf[100000]; | ||
23 | for(;;) | ||
24 | { | ||
25 | int iRead = fIn.read( buf, 100000 ); | ||
26 | m.addData( buf, iRead ); | ||
27 | if( iRead < 100000 ) | ||
28 | break; | ||
29 | } | ||
30 | |||
31 | sio << m.getHexResult() << " *" << *argv << sio.nl; | ||
32 | } | ||
33 | } | ||
34 | |||
diff --git a/src/tests/minicron.cpp b/src/tests/minicron.cpp deleted file mode 100644 index aed63e2..0000000 --- a/src/tests/minicron.cpp +++ /dev/null | |||
@@ -1,63 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/minicron.h" | ||
9 | #include "bu/sio.h" | ||
10 | |||
11 | #include <unistd.h> | ||
12 | |||
13 | using namespace Bu; | ||
14 | |||
15 | Bu::MiniCron mCron; | ||
16 | |||
17 | void job0( Bu::MiniCron::Job &job ) | ||
18 | { | ||
19 | sio << time( NULL ) << ": job0( id = " << job.getId() << ", count = " | ||
20 | << job.getRunCount() << ")" << sio.nl; | ||
21 | } | ||
22 | |||
23 | void job1( Bu::MiniCron::Job &job ) | ||
24 | { | ||
25 | sio << time( NULL ) << ": job1( id = " << job.getId() << ", count = " | ||
26 | << job.getRunCount() << ")" << sio.nl; | ||
27 | mCron.removeJob( 4 ); | ||
28 | } | ||
29 | |||
30 | void job2( Bu::MiniCron::Job &job ) | ||
31 | { | ||
32 | sio << time( NULL ) << ": job2( id = " << job.getId() << ", count = " | ||
33 | << job.getRunCount() << ")" << sio.nl; | ||
34 | } | ||
35 | |||
36 | void job3( Bu::MiniCron::Job &job ) | ||
37 | { | ||
38 | sio << time( NULL ) << ": job3( id = " << job.getId() << ", count = " | ||
39 | << job.getRunCount() << ")" << sio.nl; | ||
40 | } | ||
41 | |||
42 | int main() | ||
43 | { | ||
44 | mCron.addJob( | ||
45 | "job0", slot( &job0 ), MiniCron::TimerInterval( time(NULL)+3, 5 ) ); | ||
46 | mCron.addJob( | ||
47 | "job1", slot( &job1 ), MiniCron::TimerInterval( time(NULL)+10, 8 ) ); | ||
48 | mCron.addJob( | ||
49 | "job2", slot( &job2 ), MiniCron::TimerBasic("weekly wed 17") ); | ||
50 | mCron.addJob( | ||
51 | "job3", slot( &job3 ), MiniCron::TimerInterval( time(NULL)+1, 2 ) ); | ||
52 | |||
53 | sio << time( NULL ) << ": Program started." << sio.nl; | ||
54 | |||
55 | for(;;) | ||
56 | { | ||
57 | usleep( 50000 ); | ||
58 | mCron.poll(); | ||
59 | } | ||
60 | |||
61 | return 0; | ||
62 | } | ||
63 | |||
diff --git a/src/tests/mmparse.cpp b/src/tests/mmparse.cpp deleted file mode 100644 index c1ce862..0000000 --- a/src/tests/mmparse.cpp +++ /dev/null | |||
@@ -1,22 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/minimacro.h" | ||
9 | #include "bu/string.h" | ||
10 | |||
11 | int main() | ||
12 | { | ||
13 | Bu::MiniMacro mm; | ||
14 | |||
15 | mm.addVar("name", "Mike"); | ||
16 | mm.addVar("age", "no"); | ||
17 | |||
18 | printf("%s\n", mm.parse("Hey there {=name:toupper():tolower()}, how are you?").getStr() ); | ||
19 | |||
20 | return 0; | ||
21 | } | ||
22 | |||
diff --git a/src/tests/multiserver.cpp b/src/tests/multiserver.cpp deleted file mode 100644 index 12f4681..0000000 --- a/src/tests/multiserver.cpp +++ /dev/null | |||
@@ -1,76 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/multiserver.h" | ||
9 | #include "bu/protocol.h" | ||
10 | #include "bu/client.h" | ||
11 | |||
12 | class ProtocolRaw : public Bu::Protocol | ||
13 | { | ||
14 | public: | ||
15 | virtual void onNewConnection( Bu::Client *pClient ) | ||
16 | { | ||
17 | pClient->write("Raw echo\n"); | ||
18 | } | ||
19 | |||
20 | virtual void onNewData( Bu::Client *pClient ) | ||
21 | { | ||
22 | char buf[1024]; | ||
23 | while( pClient->hasInput() ) | ||
24 | { | ||
25 | int iAmnt = pClient->read( buf, 1024 ); | ||
26 | pClient->write( buf, iAmnt ); | ||
27 | } | ||
28 | } | ||
29 | }; | ||
30 | |||
31 | class ProtocolRot13 : public Bu::Protocol | ||
32 | { | ||
33 | public: | ||
34 | virtual void onNewConnection( Bu::Client *pClient ) | ||
35 | { | ||
36 | pClient->write("Rot13 echo\n"); | ||
37 | } | ||
38 | |||
39 | virtual void onNewData( Bu::Client *pClient ) | ||
40 | { | ||
41 | while( pClient->hasInput() ) | ||
42 | { | ||
43 | char sTmp[1024]; | ||
44 | int iAmnt = pClient->read( sTmp, 1024 ); | ||
45 | for( int j = 0; j < iAmnt; j++ ) | ||
46 | { | ||
47 | if( sTmp[j] >= 'a' && sTmp[j] <= 'z' ) | ||
48 | { | ||
49 | sTmp[j] = ((sTmp[j]-'a'+13)%26) + 'a'; | ||
50 | } | ||
51 | else if( sTmp[j] >= 'A' && sTmp[j] <= 'Z' ) | ||
52 | { | ||
53 | sTmp[j] = ((sTmp[j]-'A'+13)%26) + 'A'; | ||
54 | } | ||
55 | } | ||
56 | pClient->write( sTmp, iAmnt ); | ||
57 | } | ||
58 | } | ||
59 | }; | ||
60 | |||
61 | int main() | ||
62 | { | ||
63 | Bu::MultiServer msMain; | ||
64 | |||
65 | msMain.addProtocol( Bu::genProtocol<ProtocolRaw>, 5550 ); | ||
66 | msMain.addProtocol( Bu::genProtocol<ProtocolRot13>, 5551 ); | ||
67 | msMain.setTimeout( 5, 0 ); | ||
68 | |||
69 | for(;;) | ||
70 | { | ||
71 | msMain.scan(); | ||
72 | } | ||
73 | |||
74 | return 0; | ||
75 | } | ||
76 | |||
diff --git a/src/tests/procs.cpp b/src/tests/procs.cpp deleted file mode 100644 index 94d2cc5..0000000 --- a/src/tests/procs.cpp +++ /dev/null | |||
@@ -1,37 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/process.h" | ||
9 | |||
10 | #include <stdio.h> | ||
11 | |||
12 | int main() | ||
13 | { | ||
14 | Bu::Process p( Bu::Process::Both, "/bin/bash", "/bin/bash", "-c", "echo Hello 1>&2; echo StdOut; sleep 1; echo Yup; echo Yup 1>&2", NULL ); | ||
15 | |||
16 | char buf[1000]; | ||
17 | while( !p.isEos() ) | ||
18 | { | ||
19 | bool out, err; | ||
20 | p.select( out, err ); | ||
21 | if( out ) | ||
22 | { | ||
23 | int iSize = p.read( buf, 1000 ); | ||
24 | printf("::read=%d::\n", iSize ); | ||
25 | fwrite( buf, iSize, 1, stdout ); | ||
26 | } | ||
27 | if( err ) | ||
28 | { | ||
29 | int iSize = p.readErr( buf, 1000 ); | ||
30 | printf("::readErr=%d::\n", iSize ); | ||
31 | fwrite( buf, iSize, 1, stdout ); | ||
32 | } | ||
33 | } | ||
34 | |||
35 | return 0; | ||
36 | } | ||
37 | |||
diff --git a/src/tests/queuebuf.cpp b/src/tests/queuebuf.cpp deleted file mode 100644 index f872738..0000000 --- a/src/tests/queuebuf.cpp +++ /dev/null | |||
@@ -1,66 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include <bu/queuebuf.h> | ||
9 | #include <bu/sio.h> | ||
10 | |||
11 | using namespace Bu; | ||
12 | |||
13 | int main() | ||
14 | { | ||
15 | static const char *src = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789%#"; | ||
16 | QueueBuf qb; | ||
17 | |||
18 | for( int j = 0; j < 8; j++ ) | ||
19 | { | ||
20 | qb.write( src, 60 ); | ||
21 | } | ||
22 | |||
23 | char buf[11], bufp[11]; | ||
24 | while( !qb.isEos() ) | ||
25 | { | ||
26 | int iAmntPeek = qb.peek( bufp, 9 ); | ||
27 | int iAmntRead = qb.read( buf, 9 ); | ||
28 | if( iAmntPeek != iAmntRead ) | ||
29 | sio << "Differ: " << iAmntPeek << " vs " << iAmntRead << sio.nl; | ||
30 | buf[iAmntRead] = '\0'; | ||
31 | bufp[iAmntPeek] = '\0'; | ||
32 | if( memcmp( buf, bufp, iAmntPeek ) ) | ||
33 | { | ||
34 | sio << "Buffers differ" << sio.nl | ||
35 | << " " << buf << sio.nl | ||
36 | << " " << bufp << sio.nl; | ||
37 | } | ||
38 | else | ||
39 | sio << "Read: >>" << buf << "<<" << sio.nl; | ||
40 | } | ||
41 | |||
42 | sio << sio.nl << sio.nl << sio.nl << "Seek test:" << sio.nl << sio.nl; | ||
43 | |||
44 | for( int j = 0; j < 5; j++ ) | ||
45 | { | ||
46 | qb.write( src, 25 ); | ||
47 | qb.write( src+10, 25 ); | ||
48 | } | ||
49 | |||
50 | char bufa[26]; | ||
51 | char bufb[26]; | ||
52 | ::memcpy( bufb, src+10, 15 ); | ||
53 | ::memcpy( bufb+15, src+10, 10 ); | ||
54 | bufb[25] = '\0'; | ||
55 | sio << "Comparing to '" << bufb << "'" << sio.nl; | ||
56 | qb.seek( 10 ); | ||
57 | while( !qb.isEos() ) | ||
58 | { | ||
59 | bufa[qb.read( bufa, 25 )] = '\0'; | ||
60 | qb.seek( 25 ); | ||
61 | if( memcmp( bufa, bufb, 25 ) ) | ||
62 | sio << "Differ?" << sio.nl; | ||
63 | sio << "=== '" << bufa << "' == '" << bufb << "'" << sio.nl; | ||
64 | } | ||
65 | } | ||
66 | |||
diff --git a/src/tests/regex.cpp b/src/tests/regex.cpp deleted file mode 100644 index 376fbb2..0000000 --- a/src/tests/regex.cpp +++ /dev/null | |||
@@ -1,38 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include <bu/regex.h> | ||
9 | #include <stdio.h> | ||
10 | |||
11 | int main( int argc, char *argv[] ) | ||
12 | { | ||
13 | if( argc < 3 ) | ||
14 | { | ||
15 | printf("No... %s <regex> <string>\n\n", argv[0] ); | ||
16 | return 0; | ||
17 | } | ||
18 | |||
19 | Bu::RegEx re( argv[1] ); | ||
20 | |||
21 | printf("Regex: %s\n", argv[1] ); | ||
22 | printf("Match: %s\n", argv[2] ); | ||
23 | |||
24 | if( re.execute( argv[2] ) ) | ||
25 | { | ||
26 | for( int j = 0; j < re.getNumSubStrings(); j++ ) | ||
27 | { | ||
28 | printf("SubStr %d: %s\n", j, re.getSubString( j ).getStr() ); | ||
29 | } | ||
30 | } | ||
31 | else | ||
32 | { | ||
33 | printf("Regex did not match.\n"); | ||
34 | } | ||
35 | |||
36 | return 0; | ||
37 | } | ||
38 | |||
diff --git a/src/tests/ringbuffer.cpp b/src/tests/ringbuffer.cpp deleted file mode 100644 index da5126c..0000000 --- a/src/tests/ringbuffer.cpp +++ /dev/null | |||
@@ -1,38 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/ringbuffer.h" | ||
9 | #include <stdlib.h> | ||
10 | #include <stdint.h> | ||
11 | #include <stdio.h> | ||
12 | |||
13 | int main() | ||
14 | { | ||
15 | Bu::RingBuffer<uint32_t> ibuf( 10 ); | ||
16 | |||
17 | for( int k = 0; k < 2; k++ ) | ||
18 | { | ||
19 | int j = 1; | ||
20 | for(; j < 7; j++ ) | ||
21 | { | ||
22 | ibuf.enqueue( j ); | ||
23 | } | ||
24 | |||
25 | for(; j < 20; j++ ) | ||
26 | { | ||
27 | ibuf.enqueue( j ); | ||
28 | printf("- %d\n", ibuf.dequeue() ); | ||
29 | } | ||
30 | |||
31 | for(;;) | ||
32 | { | ||
33 | if( ibuf.isEmpty() ) break; | ||
34 | printf(". %d\n", ibuf.dequeue() ); | ||
35 | } | ||
36 | } | ||
37 | } | ||
38 | |||
diff --git a/src/tests/rot13.cpp b/src/tests/rot13.cpp deleted file mode 100644 index 1530af3..0000000 --- a/src/tests/rot13.cpp +++ /dev/null | |||
@@ -1,91 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/protocol.h" | ||
9 | #include "bu/multiserver.h" | ||
10 | #include "bu/client.h" | ||
11 | #include "bu/filter.h" | ||
12 | |||
13 | using namespace Bu; | ||
14 | |||
15 | class Rot13Filter : public Filter | ||
16 | { | ||
17 | public: | ||
18 | Rot13Filter( Stream &next ) : | ||
19 | Filter( next ) | ||
20 | { | ||
21 | } | ||
22 | |||
23 | virtual ~Rot13Filter() | ||
24 | { | ||
25 | } | ||
26 | |||
27 | virtual void start() | ||
28 | { | ||
29 | } | ||
30 | |||
31 | virtual Bu::size stop() | ||
32 | { | ||
33 | return 0; | ||
34 | } | ||
35 | |||
36 | virtual Bu::size read( void *pBuf, Bu::size nBytes ) | ||
37 | { | ||
38 | return rNext.read( pBuf, nBytes ); | ||
39 | } | ||
40 | |||
41 | virtual Bu::size write( const void *pBuf, Bu::size nBytes ) | ||
42 | { | ||
43 | const char *cBuf = (const char *)pBuf; | ||
44 | char *buf = new char[nBytes]; | ||
45 | for( Bu::size j = 0; j < nBytes; j++ ) | ||
46 | { | ||
47 | if( cBuf[j] >= 'a' && cBuf[j] <= 'z' ) | ||
48 | buf[j] = (cBuf[j]-'a'+13)%26+'a'; | ||
49 | else if( cBuf[j] >= 'A' && cBuf[j] <= 'Z' ) | ||
50 | buf[j] = (cBuf[j]-'A'+13)%26+'A'; | ||
51 | else | ||
52 | buf[j] = cBuf[j]; | ||
53 | } | ||
54 | rNext.write( buf, nBytes ); | ||
55 | delete[] buf; | ||
56 | return nBytes; | ||
57 | } | ||
58 | }; | ||
59 | |||
60 | class Rot13Protocol : public Protocol | ||
61 | { | ||
62 | public: | ||
63 | void onNewConnection( Bu::Client *pClient ) | ||
64 | { | ||
65 | pClient->pushFilter<Rot13Filter>(); | ||
66 | } | ||
67 | |||
68 | void onNewData( Bu::Client *pClient ) | ||
69 | { | ||
70 | char buf[1024]; | ||
71 | while( pClient->hasInput() ) | ||
72 | { | ||
73 | int iAmnt = pClient->read( buf, 1024 ); | ||
74 | pClient->write( buf, iAmnt ); | ||
75 | } | ||
76 | } | ||
77 | }; | ||
78 | |||
79 | int main() | ||
80 | { | ||
81 | MultiServer xSrv; | ||
82 | |||
83 | xSrv.setTimeout( 5 ); | ||
84 | xSrv.addProtocol( genProtocol<Rot13Protocol>, 9999 ); | ||
85 | |||
86 | for(;;) | ||
87 | xSrv.scan(); | ||
88 | |||
89 | return 0; | ||
90 | } | ||
91 | |||
diff --git a/src/tests/serverticks.cpp b/src/tests/serverticks.cpp deleted file mode 100644 index 3872a16..0000000 --- a/src/tests/serverticks.cpp +++ /dev/null | |||
@@ -1,69 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/server.h" | ||
9 | #include "bu/client.h" | ||
10 | #include "bu/protocol.h" | ||
11 | #include <unistd.h> | ||
12 | |||
13 | class TickProtocol : public Bu::Protocol | ||
14 | { | ||
15 | public: | ||
16 | TickProtocol() | ||
17 | { | ||
18 | } | ||
19 | |||
20 | virtual ~TickProtocol() | ||
21 | { | ||
22 | } | ||
23 | |||
24 | virtual void onTick( Bu::Client *pClient ) | ||
25 | { | ||
26 | printf("tick!\n"); | ||
27 | pClient->write("tick!\n"); | ||
28 | } | ||
29 | }; | ||
30 | |||
31 | class TickServer : public Bu::Server | ||
32 | { | ||
33 | public: | ||
34 | TickServer() | ||
35 | { | ||
36 | } | ||
37 | |||
38 | virtual ~TickServer() | ||
39 | { | ||
40 | } | ||
41 | |||
42 | virtual void onNewConnection( Bu::Client *pClient, int ) | ||
43 | { | ||
44 | pClient->setProtocol( new TickProtocol() ); | ||
45 | } | ||
46 | |||
47 | virtual void onClosedConnection( Bu::Client *pClient ) | ||
48 | { | ||
49 | delete pClient->getProtocol(); | ||
50 | } | ||
51 | }; | ||
52 | |||
53 | int main( int , char *[] ) | ||
54 | { | ||
55 | TickServer ts; | ||
56 | |||
57 | ts.setTimeout( 1, 0 ); | ||
58 | ts.setAutoTick(); | ||
59 | ts.addPort( 5555 ); | ||
60 | |||
61 | for(;;) | ||
62 | { | ||
63 | ts.scan(); | ||
64 | sleep( 1 ); | ||
65 | } | ||
66 | |||
67 | return 0; | ||
68 | } | ||
69 | |||
diff --git a/src/tests/sha1.cpp b/src/tests/sha1.cpp deleted file mode 100644 index ac795e7..0000000 --- a/src/tests/sha1.cpp +++ /dev/null | |||
@@ -1,39 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/sio.h" | ||
9 | #include "bu/file.h" | ||
10 | #include "bu/sha1.h" | ||
11 | |||
12 | using namespace Bu; | ||
13 | |||
14 | int main( int argc, char *argv[] ) | ||
15 | { | ||
16 | argv++, argc--; | ||
17 | for(; *argv; argv++ ) | ||
18 | { | ||
19 | Bu::File fIn( *argv, Bu::File::Read ); | ||
20 | Bu::Sha1 m; | ||
21 | |||
22 | char buf[100000]; | ||
23 | for(;;) | ||
24 | { | ||
25 | int iRead = fIn.read( buf, 100000 ); | ||
26 | m.addData( buf, iRead ); | ||
27 | if( iRead < 100000 ) | ||
28 | break; | ||
29 | } | ||
30 | |||
31 | Bu::String sRes = m.getResult(); | ||
32 | for( Bu::String::iterator i = sRes.begin(); i; i++ ) | ||
33 | { | ||
34 | sio << Fmt::hex(2,false) << (int)(unsigned char)(*i); | ||
35 | } | ||
36 | sio << " *" << *argv << sio.nl; | ||
37 | } | ||
38 | } | ||
39 | |||
diff --git a/src/tests/sharedcore.cpp b/src/tests/sharedcore.cpp deleted file mode 100644 index c68f07b..0000000 --- a/src/tests/sharedcore.cpp +++ /dev/null | |||
@@ -1,98 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/sharedcore.h" | ||
9 | #include "bu/sio.h" | ||
10 | |||
11 | using namespace Bu; | ||
12 | |||
13 | struct ShintCore | ||
14 | { | ||
15 | int val; | ||
16 | }; | ||
17 | class Shint : public Bu::SharedCore<Shint, struct ShintCore> | ||
18 | { | ||
19 | public: | ||
20 | Shint() | ||
21 | { | ||
22 | core->val = 0; | ||
23 | } | ||
24 | |||
25 | Shint( int val ) | ||
26 | { | ||
27 | core->val = val; | ||
28 | } | ||
29 | |||
30 | int getVal() const | ||
31 | { | ||
32 | return core->val; | ||
33 | } | ||
34 | |||
35 | void setValBad( int val ) | ||
36 | { | ||
37 | core->val = val; | ||
38 | } | ||
39 | |||
40 | void setVal( int val ) | ||
41 | { | ||
42 | _hardCopy(); | ||
43 | core->val = val; | ||
44 | } | ||
45 | |||
46 | bool operator==( const Shint &rhs ) | ||
47 | { | ||
48 | if( core == rhs.core ) | ||
49 | { | ||
50 | sio << "Same pointer (" << Fmt::ptr() << core << ")" << sio.nl; | ||
51 | return true; | ||
52 | } | ||
53 | if( core->val == rhs.core->val ) | ||
54 | { | ||
55 | sio << "Same value " << core->val << " (" | ||
56 | << Fmt::ptr() << core << " vs " | ||
57 | << Fmt::ptr() << rhs.core << ")" | ||
58 | << sio.nl; | ||
59 | return true; | ||
60 | } | ||
61 | sio << "Different" << sio.nl; | ||
62 | return false; | ||
63 | } | ||
64 | }; | ||
65 | |||
66 | #define line( x ) sio << __FILE__ ": " << __LINE__ << ": " << #x << sio.nl; x | ||
67 | |||
68 | int main() | ||
69 | { | ||
70 | line( Shint a; ) | ||
71 | line( Shint b( 5 ); ) | ||
72 | |||
73 | line( a == b; ) | ||
74 | |||
75 | line( b = a; ) | ||
76 | line( a == b; ) | ||
77 | |||
78 | line( b.setValBad( 12 ); ) | ||
79 | sio << a.getVal() << " != " << b.getVal() << sio.nl; | ||
80 | line( a == b; ) | ||
81 | |||
82 | line( a.setVal( 3 ); ) | ||
83 | sio << a.getVal() << " != " << b.getVal() << sio.nl; | ||
84 | line( a == b; ) | ||
85 | |||
86 | line( a.setVal( b.getVal() ); ) | ||
87 | line( a == b; ) | ||
88 | |||
89 | { | ||
90 | Shint c( b ); | ||
91 | Shint d( c ); | ||
92 | sio << c.getVal(); | ||
93 | d.setVal( 43 ); | ||
94 | } | ||
95 | |||
96 | sio << b.getVal(); | ||
97 | } | ||
98 | |||
diff --git a/src/tests/signals.cpp b/src/tests/signals.cpp deleted file mode 100644 index 14bbc9c..0000000 --- a/src/tests/signals.cpp +++ /dev/null | |||
@@ -1,131 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include <bu/signals.h> | ||
9 | #include <bu/sio.h> | ||
10 | |||
11 | using namespace Bu; | ||
12 | |||
13 | class Thing | ||
14 | { | ||
15 | public: | ||
16 | Thing() : | ||
17 | iState( 82731 ) | ||
18 | { | ||
19 | } | ||
20 | |||
21 | virtual ~Thing() | ||
22 | { | ||
23 | } | ||
24 | |||
25 | void fnc0() | ||
26 | { | ||
27 | sio << iState << ": void fnc0()" << sio.nl; | ||
28 | } | ||
29 | |||
30 | void fnc1( int a ) | ||
31 | { | ||
32 | sio << iState << ": void fnc1( " << a << " )" << sio.nl; | ||
33 | } | ||
34 | |||
35 | void fnc2( int a, Bu::String b ) | ||
36 | { | ||
37 | sio << iState << ": void fnc2( " << a << ", \"" << b << "\" )" << sio.nl; | ||
38 | } | ||
39 | |||
40 | void fnc3( int a, Bu::String b, double c ) | ||
41 | { | ||
42 | sio << iState << ": void fnc3( " << a << ", \"" << b << "\", " << c << " )" << sio.nl; | ||
43 | } | ||
44 | |||
45 | void fnc4( int a, Bu::String b, double c, char d ) | ||
46 | { | ||
47 | sio << iState << ": void fnc4( " << a << ", \"" << b << "\", " << c << ", '" << d << "' )" << sio.nl; | ||
48 | } | ||
49 | |||
50 | void fnc5( int a, Bu::String b, double c, char d, long e ) | ||
51 | { | ||
52 | sio << iState << ": void fnc5( " << a << ", \"" << b << "\", " << c << ", '" << d << "', " << e << " )" << sio.nl; | ||
53 | } | ||
54 | |||
55 | private: | ||
56 | int iState; | ||
57 | }; | ||
58 | |||
59 | void pfnc0() | ||
60 | { | ||
61 | sio << ": void pfnc0()" << sio.nl; | ||
62 | } | ||
63 | |||
64 | void pfnc1( int a ) | ||
65 | { | ||
66 | sio << ": void pfnc1( " << a << " )" << sio.nl; | ||
67 | } | ||
68 | |||
69 | void pfnc2( int a, Bu::String b ) | ||
70 | { | ||
71 | sio << ": void pfnc2( " << a << ", \"" << b << "\" )" << sio.nl; | ||
72 | } | ||
73 | |||
74 | void pfnc3( int a, Bu::String b, double c ) | ||
75 | { | ||
76 | sio << ": void pfnc3( " << a << ", \"" << b << "\", " << c << " )" << sio.nl; | ||
77 | } | ||
78 | |||
79 | void pfnc4( int a, Bu::String b, double c, char d ) | ||
80 | { | ||
81 | sio << ": void pfnc4( " << a << ", \"" << b << "\", " << c << ", '" << d << "' )" << sio.nl; | ||
82 | } | ||
83 | |||
84 | void pfnc5( int a, Bu::String b, double c, char d, long e ) | ||
85 | { | ||
86 | sio << ": void pfnc5( " << a << ", \"" << b << "\", " << c << ", '" << d << "', " << e << " )" << sio.nl; | ||
87 | } | ||
88 | |||
89 | void callit( Signal0<void> sig ) | ||
90 | { | ||
91 | sig(); | ||
92 | } | ||
93 | |||
94 | int main() | ||
95 | { | ||
96 | Thing t; | ||
97 | |||
98 | Signal0<void> cb0( slot( &t, &Thing::fnc0 ) ); | ||
99 | cb0(); | ||
100 | cb0 = slot( &pfnc0 ); | ||
101 | cb0(); | ||
102 | |||
103 | Signal1<void, int> cb1( slot( &t, &Thing::fnc1 ) ); | ||
104 | cb1( 5 ); | ||
105 | cb1 = slot( &pfnc1 ); | ||
106 | cb1( 5 ); | ||
107 | |||
108 | Signal2<void, int, Bu::String> cb2( slot( &t, &Thing::fnc2 ) ); | ||
109 | cb2( 5, "Hi there" ); | ||
110 | cb2 = slot( &pfnc2 ); | ||
111 | cb2( 5, "Hi there" ); | ||
112 | |||
113 | Signal3<void, int, Bu::String, double> cb3( slot( &t, &Thing::fnc3 ) ); | ||
114 | cb3( 5, "Hi there", 12.85 ); | ||
115 | cb3 = slot( &pfnc3 ); | ||
116 | cb3( 5, "Hi there", 12.85 ); | ||
117 | |||
118 | Signal4<void, int, Bu::String, double, char> cb4( slot( &t, &Thing::fnc4 ) ); | ||
119 | cb4( 5, "Hi there", 12.85, 'z' ); | ||
120 | cb4 = slot( &pfnc4 ); | ||
121 | cb4( 5, "Hi there", 12.85, 'z' ); | ||
122 | |||
123 | Signal5<void, int, Bu::String, double, char, long> cb5( slot( &t, &Thing::fnc5 ) ); | ||
124 | cb5( 5, "Hi there", 12.85, 'z', 849 ); | ||
125 | cb5 = slot( &pfnc5 ); | ||
126 | cb5( 5, "Hi there", 12.85, 'z', 849 ); | ||
127 | |||
128 | // Signal1<int, int> cb1( slot( &t, &Thing::fnc1 ) ); | ||
129 | // sio << "Result: " << cb1( 5 ) << sio.nl; | ||
130 | } | ||
131 | |||
diff --git a/src/tests/size.cpp b/src/tests/size.cpp deleted file mode 100644 index dfad16f..0000000 --- a/src/tests/size.cpp +++ /dev/null | |||
@@ -1,20 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/hash.h" | ||
9 | #include "bu/string.h" | ||
10 | |||
11 | #define pSize( t ) printf("%15s: %db\n", #t, sizeof( t ) ); | ||
12 | |||
13 | int main() | ||
14 | { | ||
15 | typedef Bu::Hash<char, char> charcharHash; | ||
16 | typedef Bu::Hash<Bu::String, Bu::String> strstrHash; | ||
17 | pSize( Bu::String ); | ||
18 | pSize( charcharHash ); | ||
19 | pSize( strstrHash ); | ||
20 | } | ||
diff --git a/src/tests/socketblock.cpp b/src/tests/socketblock.cpp deleted file mode 100644 index e36bb33..0000000 --- a/src/tests/socketblock.cpp +++ /dev/null | |||
@@ -1,56 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/ito.h" | ||
9 | #include "bu/tcpsocket.h" | ||
10 | #include "bu/tcpserversocket.h" | ||
11 | #include <stdio.h> | ||
12 | #include <unistd.h> | ||
13 | |||
14 | class TstServer : public Bu::Ito | ||
15 | { | ||
16 | public: | ||
17 | TstServer() : | ||
18 | s( 55678 ) | ||
19 | { | ||
20 | } | ||
21 | |||
22 | virtual void run() | ||
23 | { | ||
24 | Bu::TcpSocket c = s.accept( 45, 0 ); | ||
25 | printf("TstServer: Accetped connection.\n"); fflush( stdout ); | ||
26 | |||
27 | sleep( 1 ); | ||
28 | printf("TstServer: Trying to read 10 bytes...\n"); fflush( stdout ); | ||
29 | |||
30 | char buf[10]; | ||
31 | size_t nRead = c.read( buf, 10 ); | ||
32 | printf("TstServer: Got %d bytes...\n", nRead ); fflush( stdout ); | ||
33 | |||
34 | printf("TstServer: Closing connection...\n"); fflush( stdout ); | ||
35 | c.close(); | ||
36 | } | ||
37 | |||
38 | Bu::TcpServerSocket s; | ||
39 | }; | ||
40 | |||
41 | int main() | ||
42 | { | ||
43 | TstServer ts; | ||
44 | |||
45 | ts.start(); | ||
46 | |||
47 | printf("main: Connecting to server.\n"); fflush( stdout ); | ||
48 | Bu::TcpSocket s( "localhost", 55678 ); | ||
49 | |||
50 | printf("main: Sending 4 bytes.\n"); fflush( stdout ); | ||
51 | s.write( "aoeu", 4 ); | ||
52 | |||
53 | printf("main: Sleeping 10 seconds for good measure.\n"); fflush( stdout ); | ||
54 | sleep( 10 ); | ||
55 | } | ||
56 | |||
diff --git a/src/tests/socketbreak.cpp b/src/tests/socketbreak.cpp deleted file mode 100644 index d58ebcf..0000000 --- a/src/tests/socketbreak.cpp +++ /dev/null | |||
@@ -1,35 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/tcpserversocket.h" | ||
9 | #include "bu/tcpsocket.h" | ||
10 | #include <unistd.h> | ||
11 | |||
12 | int main() | ||
13 | { | ||
14 | Bu::TcpServerSocket sSrv( 9987 ); | ||
15 | |||
16 | Bu::TcpSocket sSend("localhost", 9987 ); | ||
17 | |||
18 | Bu::TcpSocket sRecv( sSrv.accept() ); | ||
19 | |||
20 | printf("Connected sockets.\n"); | ||
21 | |||
22 | sleep( 1 ); | ||
23 | printf("Closing sRecv.\n"); | ||
24 | sRecv.close(); | ||
25 | sleep( 1 ); | ||
26 | |||
27 | char buf[3]; | ||
28 | printf("About to write.\n"); | ||
29 | printf("write: %lld\n", sSend.write("hi", 2 ) ); | ||
30 | printf("About to read.\n"); | ||
31 | printf("read: %lld\n", sSend.read( buf, 2 ) ); | ||
32 | |||
33 | return 0; | ||
34 | } | ||
35 | |||
diff --git a/src/tests/speed.cpp b/src/tests/speed.cpp deleted file mode 100644 index 2fa29aa..0000000 --- a/src/tests/speed.cpp +++ /dev/null | |||
@@ -1,58 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/string.h" | ||
9 | #include <sys/time.h> | ||
10 | |||
11 | template<typename a> | ||
12 | struct tstCopy | ||
13 | { | ||
14 | tstCopy( const a &src ) : | ||
15 | src( src ) | ||
16 | { | ||
17 | } | ||
18 | |||
19 | void operator()() | ||
20 | { | ||
21 | a tmp = src; | ||
22 | } | ||
23 | |||
24 | a src; | ||
25 | }; | ||
26 | |||
27 | template<typename f> | ||
28 | double runTest( f fnc ) | ||
29 | { | ||
30 | struct timeval tStart, tEnd; | ||
31 | int j = 0; | ||
32 | gettimeofday( &tStart, NULL ); | ||
33 | for(; j < 500000; j++ ) | ||
34 | fnc(); | ||
35 | gettimeofday( &tEnd, NULL ); | ||
36 | |||
37 | return (double)(tEnd.tv_sec-tStart.tv_sec)+ | ||
38 | (double)(tEnd.tv_usec-tStart.tv_usec)/1000000.0; | ||
39 | } | ||
40 | |||
41 | template<typename tst> | ||
42 | void fullTest( tst t ) | ||
43 | { | ||
44 | double dTotal; | ||
45 | int iCount = 10; | ||
46 | for( int j = 0; j < iCount; j++ ) | ||
47 | dTotal += runTest( t ); | ||
48 | printf("Average time: %f\n", dTotal/iCount ); | ||
49 | } | ||
50 | |||
51 | int main() | ||
52 | { | ||
53 | Bu::String str; | ||
54 | for( int j = 0; j < 500; j++ ) | ||
55 | str.append("Hey, this is a test string. It will be reapeated many, many times. How's that?"); | ||
56 | fullTest( tstCopy<Bu::String>( str ) ); | ||
57 | } | ||
58 | |||
diff --git a/src/tests/stdstream.cpp b/src/tests/stdstream.cpp deleted file mode 100644 index 95df42e..0000000 --- a/src/tests/stdstream.cpp +++ /dev/null | |||
@@ -1,39 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/sio.h" | ||
9 | |||
10 | using Bu::sio; | ||
11 | using Bu::Fmt; | ||
12 | |||
13 | int main() | ||
14 | { | ||
15 | sio << "Hello there" << sio.nl; | ||
16 | |||
17 | sio << "sizeof(Fmt) = " << sizeof(Fmt) << sio.nl; | ||
18 | |||
19 | sio << -123 << ", " << 0 << ", " << 123 << sio.nl; | ||
20 | |||
21 | sio << "+----------+" << sio.nl; | ||
22 | sio << "|" << Fmt( 10, 10, Fmt::Center ) << "Test" << "|" << sio.nl; | ||
23 | sio << "+----------+" << sio.nl; | ||
24 | sio << "|" << Fmt( 10, 10, Fmt::Left ) << 123 << "|" << sio.nl; | ||
25 | sio << "|" << Fmt( 10, 10, Fmt::Center ) << 123 << "|" << sio.nl; | ||
26 | sio << "|" << Fmt( 10, 10, Fmt::Right ) << 123 << "|" << sio.nl; | ||
27 | sio << "+----------+" << sio.nl; | ||
28 | |||
29 | sio << Fmt(10,Fmt::Left) << "Hexcode:" << Fmt::ptr() << (void*)(&sio) << sio.nl; | ||
30 | |||
31 | sio << 0.123 << sio.nl; | ||
32 | sio << true << " and then " << false << sio.nl; | ||
33 | |||
34 | for( int j = 2; j <= 36; j++ ) | ||
35 | sio << "radix(" << j << ") = " << Fmt().radix( j ).width( 8 ).align( Fmt::Right ) << 255 << sio.nl; | ||
36 | |||
37 | return 0; | ||
38 | } | ||
39 | |||
diff --git a/src/tests/streamstack.cpp b/src/tests/streamstack.cpp deleted file mode 100644 index 4a0e128..0000000 --- a/src/tests/streamstack.cpp +++ /dev/null | |||
@@ -1,100 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/streamstack.h" | ||
9 | |||
10 | #include "bu/file.h" | ||
11 | #include "bu/base64.h" | ||
12 | #include "bu/bzip2.h" | ||
13 | |||
14 | #include "bu/sio.h" | ||
15 | |||
16 | #include <time.h> | ||
17 | |||
18 | using namespace Bu; | ||
19 | |||
20 | class DoStuff | ||
21 | { | ||
22 | public: | ||
23 | DoStuff( Bu::Stream &rStream ) : | ||
24 | rStream( rStream ) | ||
25 | { | ||
26 | } | ||
27 | |||
28 | virtual ~DoStuff() | ||
29 | { | ||
30 | } | ||
31 | |||
32 | void write() | ||
33 | { | ||
34 | Bu::String s; | ||
35 | time_t tNow = time( NULL ); | ||
36 | s = ctime( &tNow ); | ||
37 | long lSize = s.getSize()-1; | ||
38 | rStream.write( &lSize, sizeof(long) ); | ||
39 | rStream.write( s.getStr(), lSize ); | ||
40 | } | ||
41 | |||
42 | void read() | ||
43 | { | ||
44 | Bu::String s; | ||
45 | long lSize; | ||
46 | rStream.read( &lSize, sizeof(long) ); | ||
47 | s.setSize( lSize ); | ||
48 | rStream.read( s.getStr(), lSize ); | ||
49 | sio << "Read str(" << lSize << ") = '" << s << "'" << sio.nl; | ||
50 | } | ||
51 | |||
52 | private: | ||
53 | Bu::Stream &rStream; | ||
54 | }; | ||
55 | |||
56 | int main() | ||
57 | { | ||
58 | Bu::StreamStack ss; | ||
59 | |||
60 | DoStuff ds( ss ); | ||
61 | |||
62 | try | ||
63 | { | ||
64 | ds.write(); | ||
65 | sio << "This shouldn't have worked." << sio.nl; | ||
66 | } | ||
67 | catch( Bu::ExceptionBase &e ) | ||
68 | { | ||
69 | sio << "Got exception, this is good: " << e.what() << sio.nl; | ||
70 | } | ||
71 | |||
72 | ss.setStream( new Bu::File("Hello.test", Bu::File::WriteNew ) ); | ||
73 | |||
74 | ds.write(); | ||
75 | |||
76 | ss.pushFilter<Bu::Base64>(); | ||
77 | |||
78 | ds.write(); | ||
79 | |||
80 | ss.pushFilter<Bu::BZip2>(); | ||
81 | |||
82 | ds.write(); | ||
83 | |||
84 | ss.clear(); | ||
85 | |||
86 | ss.setStream( new Bu::File("Hello.test", Bu::File::Read ) ); | ||
87 | |||
88 | ds.read(); | ||
89 | |||
90 | ss.pushFilter<Bu::Base64>(); | ||
91 | |||
92 | ds.read(); | ||
93 | |||
94 | ss.pushFilter<Bu::BZip2>(); | ||
95 | |||
96 | ds.read(); | ||
97 | |||
98 | return 0; | ||
99 | } | ||
100 | |||
diff --git a/src/tests/string.cpp b/src/tests/string.cpp deleted file mode 100644 index b37460e..0000000 --- a/src/tests/string.cpp +++ /dev/null | |||
@@ -1,154 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/hash.h" | ||
9 | #include "bu/string.h" | ||
10 | #include <sys/time.h> | ||
11 | #include <string> | ||
12 | |||
13 | #ifndef WIN32 | ||
14 | inline double getTime() | ||
15 | { | ||
16 | struct timeval tv; | ||
17 | gettimeofday( &tv, NULL ); | ||
18 | return ((double)tv.tv_sec) + ((double)tv.tv_usec/1000000.0); | ||
19 | } | ||
20 | #else | ||
21 | #include "windows.h" | ||
22 | #include "winbase.h" | ||
23 | inline double getTime() | ||
24 | { | ||
25 | uint32_t t = (uint32_t) GetTickCount(); | ||
26 | return (double) t / 1000.0; | ||
27 | } | ||
28 | #endif | ||
29 | |||
30 | Bu::String genThing() | ||
31 | { | ||
32 | Bu::String bob; | ||
33 | bob.append("ab "); | ||
34 | bob += "cd "; | ||
35 | bob += "efg"; | ||
36 | |||
37 | printf("---bob------\n%08tX: %s\n", (ptrdiff_t)bob.getStr(), | ||
38 | bob.getStr() ); | ||
39 | return bob; | ||
40 | } | ||
41 | |||
42 | void thing( Bu::String str ) | ||
43 | { | ||
44 | printf("Hey: %s\n", str.getStr() ); | ||
45 | } | ||
46 | |||
47 | void copyfunc( std::string temp ) | ||
48 | { | ||
49 | temp += "Hi"; | ||
50 | } | ||
51 | |||
52 | void copyfunc( Bu::String temp ) | ||
53 | { | ||
54 | temp += "Hi"; | ||
55 | } | ||
56 | |||
57 | void doTimings() | ||
58 | { | ||
59 | Bu::String fs1, fs2; | ||
60 | std::string ss1, ss2; | ||
61 | double dStart, dEnd, tfs1, tfs2, tfs3, tss1, tss2, tss3; | ||
62 | int nChars = 50000000, nChunks=50000, nCopies=500000000, nChunkSize=1024*4; | ||
63 | char *buf = new char[nChunkSize]; | ||
64 | memset( buf, '!', nChunkSize ); | ||
65 | |||
66 | printf("Timing Bu::String single chars...\n"); | ||
67 | dStart = getTime(); | ||
68 | for( int j = 0; j < nChars; j++ ) fs1 += (char)('a'+(j%26)); | ||
69 | fs1.getStr(); | ||
70 | dEnd = getTime(); | ||
71 | tfs1 = dEnd-dStart; | ||
72 | |||
73 | printf("Timing std::string single chars...\n"); | ||
74 | dStart = getTime(); | ||
75 | for( int j = 0; j < nChars; j++ ) ss1 += (char)('a'+(j%26)); | ||
76 | ss1.c_str(); | ||
77 | dEnd = getTime(); | ||
78 | tss1 = dEnd-dStart; | ||
79 | |||
80 | printf("Timing Bu::String %d char chunks...\n", nChunkSize); | ||
81 | dStart = getTime(); | ||
82 | for( int j = 0; j < nChunks; j++ ) fs2.append(buf, nChunkSize); | ||
83 | fs2.getStr(); | ||
84 | dEnd = getTime(); | ||
85 | tfs2 = dEnd-dStart; | ||
86 | |||
87 | printf("Timing std::string %d char chunks...\n", nChunkSize); | ||
88 | dStart = getTime(); | ||
89 | for( int j = 0; j < nChunks; j++ ) ss2.append(buf, nChunkSize); | ||
90 | ss2.c_str(); | ||
91 | dEnd = getTime(); | ||
92 | tss2 = dEnd-dStart; | ||
93 | |||
94 | fs2 = "Hello there."; | ||
95 | ss2 = "Hello there."; | ||
96 | printf("Timing Bu::String copies...\n"); | ||
97 | dStart = getTime(); | ||
98 | for( int j = 0; j < nCopies; j++ ) Bu::String stmp = fs2; | ||
99 | dEnd = getTime(); | ||
100 | tfs3 = dEnd-dStart; | ||
101 | |||
102 | printf("Timing std::string copies...\n"); | ||
103 | dStart = getTime(); | ||
104 | for( int j = 0; j < nCopies; j++ ) std::string stpm = ss2; | ||
105 | dEnd = getTime(); | ||
106 | tss3 = dEnd-dStart; | ||
107 | |||
108 | printf( | ||
109 | "Results: singles: chunks: copies:\n" | ||
110 | "Bu::String %15.2f/s %15.2f/s %15.2f/s\n" | ||
111 | "std::string %15.2f/s %15.2f/s %15.2f/s\n", | ||
112 | nChars/tfs1, nChunks/tfs2, nCopies/tfs3, | ||
113 | nChars/tss1, nChunks/tss2, nCopies/tss3 ); | ||
114 | |||
115 | delete[] buf; | ||
116 | } | ||
117 | |||
118 | #define pem printf("---------\n%08tX: %s\n%08tX: %s\n", (ptrdiff_t)str.getConstStr(), str.getConstStr(), (ptrdiff_t)str2.getConstStr(), str2.getConstStr() ); | ||
119 | int main( ) | ||
120 | { | ||
121 | // Bu::String fs1; | ||
122 | // for( int j = 0; j < 500000; j++ ) fs1 += (char)('a'+(j%26)); | ||
123 | // return 0; | ||
124 | |||
125 | Bu::String str("th"); | ||
126 | |||
127 | str.prepend("Hello "); | ||
128 | str.append("ere."); | ||
129 | |||
130 | Bu::String str2( str ); | ||
131 | pem; | ||
132 | str += " What's up?"; | ||
133 | pem; | ||
134 | str2 += " How are you?"; | ||
135 | pem; | ||
136 | str = str2; | ||
137 | pem; | ||
138 | |||
139 | str2 = genThing(); | ||
140 | pem; | ||
141 | |||
142 | str = str2; | ||
143 | pem; | ||
144 | |||
145 | thing( str2 ); | ||
146 | thing("test."); | ||
147 | |||
148 | printf("%d == %d\n", Bu::__calcHashCode( str ), Bu::__calcHashCode( str.getStr() ) ); | ||
149 | |||
150 | doTimings(); | ||
151 | |||
152 | return 0; | ||
153 | } | ||
154 | |||
diff --git a/src/tests/stringspeed.cpp b/src/tests/stringspeed.cpp deleted file mode 100644 index 5636de7..0000000 --- a/src/tests/stringspeed.cpp +++ /dev/null | |||
@@ -1,122 +0,0 @@ | |||
1 | #include <bu/string.h> | ||
2 | |||
3 | #include <sys/time.h> | ||
4 | #include <stdio.h> | ||
5 | |||
6 | void timeit( void (*func)(), const char *sName, int iIter ) | ||
7 | { | ||
8 | struct timeval ts, te; | ||
9 | |||
10 | gettimeofday( &ts, NULL ); | ||
11 | for( int j = 0; j < iIter; j++ ) | ||
12 | { | ||
13 | func(); | ||
14 | } | ||
15 | gettimeofday( &te, NULL ); | ||
16 | |||
17 | double dTotal = (double)(te.tv_sec-ts.tv_sec) + (double)(te.tv_usec-ts.tv_usec)/1000000.0; | ||
18 | printf("%10s: %f spi (%f total)\n", sName, dTotal/iIter, dTotal ); | ||
19 | } | ||
20 | |||
21 | void append1() | ||
22 | { | ||
23 | Bu::String sTmp; | ||
24 | for( int c = 0; c < 5000; c++ ) | ||
25 | { | ||
26 | sTmp += (char)(c%256); | ||
27 | } | ||
28 | } | ||
29 | |||
30 | void append2() | ||
31 | { | ||
32 | Bu::String sTmp; | ||
33 | for( int c = 0; c < 5000; c++ ) | ||
34 | { | ||
35 | sTmp.append( (char)(c%256) ); | ||
36 | } | ||
37 | } | ||
38 | |||
39 | void append3() | ||
40 | { | ||
41 | Bu::String sTmp; | ||
42 | for( int c = 0; c < 5000; c++ ) | ||
43 | { | ||
44 | sTmp += "Test"; | ||
45 | } | ||
46 | } | ||
47 | |||
48 | void append4() | ||
49 | { | ||
50 | Bu::String sTmp; | ||
51 | for( int c = 0; c < 5000; c++ ) | ||
52 | { | ||
53 | sTmp.append("Test"); | ||
54 | } | ||
55 | } | ||
56 | |||
57 | void append5() | ||
58 | { | ||
59 | Bu::String sTmp, sAdd("Test"); | ||
60 | for( int c = 0; c < 5000; c++ ) | ||
61 | { | ||
62 | sTmp += sAdd; | ||
63 | } | ||
64 | } | ||
65 | |||
66 | void append6() | ||
67 | { | ||
68 | Bu::String sTmp, sAdd("Test"); | ||
69 | for( int c = 0; c < 5000; c++ ) | ||
70 | { | ||
71 | sTmp.append( sAdd ); | ||
72 | } | ||
73 | } | ||
74 | |||
75 | void prepend1() | ||
76 | { | ||
77 | Bu::String sTmp; | ||
78 | for( int c = 0; c < 5000; c++ ) | ||
79 | { | ||
80 | sTmp.prepend('c'); | ||
81 | } | ||
82 | } | ||
83 | |||
84 | void copy1() | ||
85 | { | ||
86 | Bu::String sSrc; | ||
87 | for( int c = 0; c < 1000; c++ ) | ||
88 | { | ||
89 | sSrc += (char)(c%256); | ||
90 | Bu::String sTmp = sSrc; | ||
91 | sTmp.append( '-' ); | ||
92 | } | ||
93 | } | ||
94 | |||
95 | void copy2() | ||
96 | { | ||
97 | Bu::String sSrc; | ||
98 | for( int c = 0; c < 1000; c++ ) | ||
99 | { | ||
100 | sSrc += (char)(c%256); | ||
101 | Bu::String sTmp = sSrc; | ||
102 | } | ||
103 | } | ||
104 | |||
105 | void replace1() | ||
106 | { | ||
107 | Bu::String s("Hey, this is a replacement test, what do you thing of it?"); | ||
108 | s.replace("e", "X").replace("a", "X").replace("what","XXX"); | ||
109 | } | ||
110 | |||
111 | int main() | ||
112 | { | ||
113 | timeit( append1, "Append1", 5000 ); | ||
114 | timeit( append2, "Append2", 5000 ); | ||
115 | timeit( append3, "Append3", 2000 ); | ||
116 | timeit( append4, "Append4", 2000 ); | ||
117 | timeit( append4, "Prepend1", 2000 ); | ||
118 | timeit( copy1, "Copy1", 2000 ); | ||
119 | timeit( copy2, "Copy2", 2000 ); | ||
120 | timeit( replace1, "Replace1", 10000 ); | ||
121 | } | ||
122 | |||
diff --git a/src/tests/tcpsocket.cpp b/src/tests/tcpsocket.cpp deleted file mode 100644 index 89c015c..0000000 --- a/src/tests/tcpsocket.cpp +++ /dev/null | |||
@@ -1,73 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include <bu/tcpsocket.h> | ||
9 | #include <bu/sio.h> | ||
10 | |||
11 | #include <sys/time.h> | ||
12 | #include <time.h> | ||
13 | |||
14 | using namespace Bu; | ||
15 | |||
16 | bool isUp() | ||
17 | { | ||
18 | try | ||
19 | { | ||
20 | TcpSocket s("xagasoft.com", 9898, 1 ); | ||
21 | |||
22 | char buf[5]; | ||
23 | buf[s.read(buf, 2, 1, 0)] = '\0'; | ||
24 | |||
25 | if( !strcmp( buf, "hi" ) ) | ||
26 | return true; | ||
27 | else | ||
28 | return false; | ||
29 | } | ||
30 | catch(...) | ||
31 | { | ||
32 | return false; | ||
33 | } | ||
34 | } | ||
35 | |||
36 | int main() | ||
37 | { | ||
38 | uint32_t uUp = 0; | ||
39 | uint32_t uDown = 0; | ||
40 | uint32_t uTotal = 0; | ||
41 | struct timeval tv; | ||
42 | |||
43 | for(;;) | ||
44 | { | ||
45 | gettimeofday( &tv, NULL ); | ||
46 | time_t goal = ((tv.tv_sec/5)+1)*5; | ||
47 | tv.tv_sec = goal-tv.tv_sec; | ||
48 | tv.tv_usec = 0-tv.tv_usec; | ||
49 | if( tv.tv_usec < 0 ) | ||
50 | { | ||
51 | tv.tv_sec--; | ||
52 | tv.tv_usec = 1000000+tv.tv_usec; | ||
53 | } | ||
54 | select( 0, NULL, NULL, NULL, &tv ); | ||
55 | gettimeofday( &tv, NULL ); | ||
56 | if( isUp() ) | ||
57 | { | ||
58 | uUp++; | ||
59 | sio << "status: up "; | ||
60 | } | ||
61 | else | ||
62 | { | ||
63 | uDown++; | ||
64 | sio << "status: down "; | ||
65 | } | ||
66 | uTotal++; | ||
67 | |||
68 | sio << "(up=" << (uUp*5) << "s, down=" << (uDown*5) << ") up for " | ||
69 | << uUp*100/uTotal << "% of " << uTotal*5 << "s" << sio.nl | ||
70 | << sio.flush; | ||
71 | } | ||
72 | } | ||
73 | |||
diff --git a/src/tests/telnetsrv.cpp b/src/tests/telnetsrv.cpp deleted file mode 100644 index aac6b39..0000000 --- a/src/tests/telnetsrv.cpp +++ /dev/null | |||
@@ -1,92 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/server.h" | ||
9 | #include "bu/protocoltelnet.h" | ||
10 | #include "bu/client.h" | ||
11 | |||
12 | class MyTelnet : public Bu::ProtocolTelnet | ||
13 | { | ||
14 | public: | ||
15 | MyTelnet() | ||
16 | { | ||
17 | } | ||
18 | |||
19 | virtual ~MyTelnet() | ||
20 | { | ||
21 | } | ||
22 | |||
23 | virtual void onNewConnection( Bu::Client *pClient ) | ||
24 | { | ||
25 | Bu::ProtocolTelnet::onNewConnection( pClient ); | ||
26 | |||
27 | //oNAWS.remoteSet(); | ||
28 | oEcho.localSet(); | ||
29 | oSuppressGA.remoteSet( true ); | ||
30 | oSuppressGA.localSet( true ); | ||
31 | setCanonical(); | ||
32 | } | ||
33 | |||
34 | virtual void onSubNAWS( uint16_t iWidth, uint16_t iHeight ) | ||
35 | { | ||
36 | printf("New dim = (%dx%d)\n", iWidth, iHeight ); | ||
37 | } | ||
38 | |||
39 | virtual void gotLine( Bu::String &sLine ) | ||
40 | { | ||
41 | printf("Line: \"%s\"\n", sLine.getStr() ); | ||
42 | write("\n\r", 2 ); | ||
43 | } | ||
44 | |||
45 | private: | ||
46 | |||
47 | }; | ||
48 | |||
49 | class TelServer : public Bu::Server | ||
50 | { | ||
51 | public: | ||
52 | TelServer() | ||
53 | { | ||
54 | } | ||
55 | |||
56 | virtual ~TelServer() | ||
57 | { | ||
58 | } | ||
59 | |||
60 | virtual void onNewConnection( Bu::Client *pClient, int ) | ||
61 | { | ||
62 | printf("New connection.\n"); | ||
63 | |||
64 | pClient->setProtocol( new MyTelnet() ); | ||
65 | } | ||
66 | |||
67 | virtual void onClosedConnection( Bu::Client *pClient ) | ||
68 | { | ||
69 | printf("Lost connection.\n"); | ||
70 | |||
71 | delete pClient->getProtocol(); | ||
72 | } | ||
73 | |||
74 | private: | ||
75 | |||
76 | }; | ||
77 | |||
78 | int main() | ||
79 | { | ||
80 | TelServer ts; | ||
81 | |||
82 | ts.addPort( 4000 ); | ||
83 | ts.setTimeout( 0, 5000 ); | ||
84 | |||
85 | printf("Initializing server on port: 4000\n"); | ||
86 | |||
87 | for(;;) | ||
88 | { | ||
89 | ts.scan(); | ||
90 | } | ||
91 | } | ||
92 | |||
diff --git a/src/tests/tracer.cpp b/src/tests/tracer.cpp deleted file mode 100644 index 703fa1a..0000000 --- a/src/tests/tracer.cpp +++ /dev/null | |||
@@ -1,36 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | |||
9 | #define BU_TRACE | ||
10 | #include "bu/trace.h" | ||
11 | |||
12 | void doThing3( int x, const char *bob, void *p ) | ||
13 | { | ||
14 | TRACE( x, bob, p ); | ||
15 | } | ||
16 | |||
17 | void doThing2( int x, const char *bob ) | ||
18 | { | ||
19 | TRACE( x, bob ); | ||
20 | } | ||
21 | |||
22 | void doThing( int8_t x ) | ||
23 | { | ||
24 | TRACE( x ); | ||
25 | } | ||
26 | |||
27 | int main( int argc, char *argv[] ) | ||
28 | { | ||
29 | TRACE( argc, argv ); | ||
30 | doThing( 54 ); | ||
31 | doThing2( 128, "Hello" ); | ||
32 | doThing3( 266, "Goodbye", argv ); | ||
33 | |||
34 | return 0; | ||
35 | } | ||
36 | |||
diff --git a/src/tests/udpsocket.cpp b/src/tests/udpsocket.cpp deleted file mode 100644 index 2a74acf..0000000 --- a/src/tests/udpsocket.cpp +++ /dev/null | |||
@@ -1,86 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/udpsocket.h" | ||
9 | #include "bu/sio.h" | ||
10 | |||
11 | #include <errno.h> | ||
12 | #include <arpa/inet.h> | ||
13 | #include <sys/socket.h> | ||
14 | #include <netinet/in.h> | ||
15 | #include <sys/utsname.h> | ||
16 | |||
17 | using namespace Bu; | ||
18 | |||
19 | int main( int argc, char *argv[] ) | ||
20 | { | ||
21 | sio << Fmt::hex(8) << INADDR_ANY << sio.nl << Fmt::hex(8) << inet_addr("0.0.0.0") << sio.nl; | ||
22 | if( argc == 1 ) | ||
23 | { | ||
24 | sio << "Options are 'l' for listening and 'b' for broadcasting." | ||
25 | << sio.nl; | ||
26 | } | ||
27 | else if( argv[1][0] == 'l' ) | ||
28 | { | ||
29 | sio << "Listening..." << sio.nl; | ||
30 | Bu::UdpSocket udp( "0.0.0.0", 6688, UdpSocket::Read|UdpSocket::Broadcast ); | ||
31 | |||
32 | for(;;) | ||
33 | { | ||
34 | char buf[1501]; | ||
35 | int iRead = udp.read( buf, 1500 ); | ||
36 | if( iRead >= 0 ) | ||
37 | { | ||
38 | buf[iRead] = '\0'; | ||
39 | sio << "Read(" << iRead << "): '" << buf << "'" << sio.nl; | ||
40 | } | ||
41 | else | ||
42 | { | ||
43 | sio << "Got " << iRead << ": " << strerror( errno ) << sio.nl; | ||
44 | } | ||
45 | } | ||
46 | } | ||
47 | else if( argv[1][0] == 'L' ) | ||
48 | { | ||
49 | sio << "Listening..." << sio.nl; | ||
50 | Bu::UdpSocket udp( "0.0.0.0", 6688, UdpSocket::Read|UdpSocket::Broadcast ); | ||
51 | |||
52 | for(;;) | ||
53 | { | ||
54 | char buf[1501]; | ||
55 | Bu::UdpSocket::addr aHost; | ||
56 | int iPort; | ||
57 | int iRead = udp.read( buf, 1500, aHost, iPort ); | ||
58 | if( iRead >= 0 ) | ||
59 | { | ||
60 | buf[iRead] = '\0'; | ||
61 | sio << "Read(" << iRead << ") from " << Bu::UdpSocket::addrToStr( aHost ) << ":" << iPort << ": '" << buf << "'" << sio.nl; | ||
62 | } | ||
63 | } | ||
64 | } | ||
65 | else if( argv[1][0] == 'b' ) | ||
66 | { | ||
67 | sio << "Broadcasting..." << sio.nl; | ||
68 | Bu::UdpSocket udp("255.255.255.255", 6688, | ||
69 | UdpSocket::Write|UdpSocket::Broadcast ); | ||
70 | |||
71 | for(;;) | ||
72 | { | ||
73 | int iWrote = udp.write("hello", 5 ); | ||
74 | sio << "Wrote(" << iWrote << "): " << strerror( errno ) << sio.nl; | ||
75 | usleep( 250000 ); | ||
76 | } | ||
77 | } | ||
78 | else | ||
79 | { | ||
80 | sio << "Options are 'l' for listening and 'b' for broadcasting." | ||
81 | << sio.nl; | ||
82 | } | ||
83 | |||
84 | return 0; | ||
85 | } | ||
86 | |||
diff --git a/src/tests/url.cpp b/src/tests/url.cpp deleted file mode 100644 index a381cbe..0000000 --- a/src/tests/url.cpp +++ /dev/null | |||
@@ -1,42 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include "bu/url.h" | ||
9 | |||
10 | #include <stdio.h> | ||
11 | |||
12 | int main( int argc, char *argv[] ) | ||
13 | { | ||
14 | for( argc--, argv++; argc >= 0; argc--, argv++ ) | ||
15 | { | ||
16 | printf("encodede: %s\n", Bu::Url::encode( *argv ).getStr() ); | ||
17 | printf("decodede: %s\n", Bu::Url::decode( *argv ).getStr() ); | ||
18 | Bu::Url u( *argv ); | ||
19 | |||
20 | printf("Protocol: %s\n", u.getProtocol().getStr() ); | ||
21 | printf("User: %s\n", u.getUser().getStr() ); | ||
22 | printf("Pass: %s\n", u.getPass().getStr() ); | ||
23 | printf("Host: %s\n", u.getHost().getStr() ); | ||
24 | printf("Path: %s\n", u.getPath().getStr() ); | ||
25 | try | ||
26 | { | ||
27 | printf("Port: %d\n", u.getPort() ); | ||
28 | } catch( Bu::ExceptionBase &e ) | ||
29 | { | ||
30 | printf("Port: not set.\n"); | ||
31 | } | ||
32 | printf("Parameters:\n"); | ||
33 | for( Bu::Url::ParamList::const_iterator i = u.getParamBegin(); i; i++ ) | ||
34 | { | ||
35 | printf(" \"%s\" = \"%s\"\n", | ||
36 | (*i).sName.getStr(), (*i).sValue.getStr() | ||
37 | ); | ||
38 | } | ||
39 | } | ||
40 | |||
41 | return 0; | ||
42 | } | ||
diff --git a/src/tests/variant.cpp b/src/tests/variant.cpp deleted file mode 100644 index 68dec4f..0000000 --- a/src/tests/variant.cpp +++ /dev/null | |||
@@ -1,52 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2011 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #include <bu/sio.h> | ||
9 | #include <bu/variant.h> | ||
10 | #include <bu/list.h> | ||
11 | |||
12 | using namespace Bu; | ||
13 | |||
14 | Variant getThing( int i ) | ||
15 | { | ||
16 | Variant v; | ||
17 | switch( i ) | ||
18 | { | ||
19 | case 0: | ||
20 | v = 45; | ||
21 | break; | ||
22 | |||
23 | case 1: | ||
24 | v = true; | ||
25 | break; | ||
26 | |||
27 | case 2: | ||
28 | v = List<int>(5).append(10).append(15); | ||
29 | break; | ||
30 | } | ||
31 | |||
32 | return v; | ||
33 | } | ||
34 | |||
35 | int main() | ||
36 | { | ||
37 | Variant a; | ||
38 | Variant b; | ||
39 | Variant c; | ||
40 | |||
41 | a = getThing( 0 ); | ||
42 | b = getThing( 1 ); | ||
43 | c = getThing( 2 ); | ||
44 | |||
45 | sio << "a = " << a << " or " << (int)a << sio.nl | ||
46 | << "b = " << b << " or " << b.toString() << sio.nl | ||
47 | << "c = " << c << " or " << c.toString() << sio.nl | ||
48 | << sio.nl; | ||
49 | |||
50 | return 0; | ||
51 | } | ||
52 | |||
diff --git a/src/unit/string.unit b/src/unit/string.unit index 4911597..5298f8a 100644 --- a/src/unit/string.unit +++ b/src/unit/string.unit | |||
@@ -174,7 +174,7 @@ suite String | |||
174 | unitTest( a == b ); | 174 | unitTest( a == b ); |
175 | } | 175 | } |
176 | 176 | ||
177 | test iterator2 | 177 | test iteratorCompare1 |
178 | { | 178 | { |
179 | Bu::String a("This is a test."); | 179 | Bu::String a("This is a test."); |
180 | Bu::String b("--This is a test."); | 180 | Bu::String b("--This is a test."); |
@@ -185,9 +185,12 @@ suite String | |||
185 | bi++; bi++; | 185 | bi++; bi++; |
186 | unitTest( ai.compare( bi ) == true ); | 186 | unitTest( ai.compare( bi ) == true ); |
187 | unitTest( bi.compare( ai ) == true ); | 187 | unitTest( bi.compare( ai ) == true ); |
188 | b += "hi"; | ||
189 | unitTest( ai.compare( bi ) == false ); | ||
190 | unitTest( bi.compare( ai ) == false ); | ||
188 | } | 191 | } |
189 | 192 | ||
190 | test iterator3 | 193 | test iteratorCompare2 |
191 | { | 194 | { |
192 | Bu::String a("1234honour"); | 195 | Bu::String a("1234honour"); |
193 | Bu::String b("--1234ueje"); | 196 | Bu::String b("--1234ueje"); |
@@ -200,19 +203,33 @@ suite String | |||
200 | unitTest( bi.compare( ai, 4 ) == true ); | 203 | unitTest( bi.compare( ai, 4 ) == true ); |
201 | unitTest( ai.compare( bi, 5 ) == false ); | 204 | unitTest( ai.compare( bi, 5 ) == false ); |
202 | unitTest( bi.compare( ai, 5 ) == false ); | 205 | unitTest( bi.compare( ai, 5 ) == false ); |
203 | 206 | ||
207 | a = "fell"; | ||
208 | b = "-felloo"; | ||
209 | ai = a.begin(); | ||
210 | bi = b.begin()+1; | ||
211 | unitTest( ai.compare( bi, 4 ) == true ); | ||
212 | ai++; | ||
213 | bi++; | ||
214 | unitTest( ai.compare( bi, 4 ) == false ); | ||
204 | } | 215 | } |
205 | 216 | ||
206 | test iterator4 | 217 | test iteratorCompare3 |
207 | { | 218 | { |
208 | Bu::String a("1234aoeu"); | 219 | Bu::String a("1234aoeu"); |
209 | Bu::String::iterator ai = a.begin(); | 220 | Bu::String::iterator ai = a.begin(); |
210 | unitTest( ai.compare("1234") == false ); | 221 | unitTest( ai.compare("1234") == false ); |
211 | unitTest( ai.compare("1234aoeu") == true ); | 222 | unitTest( ai.compare("1234aoeu") == true ); |
212 | unitTest( ai.compare("1234aoeuee") == false ); | 223 | unitTest( ai.compare("1234aoeuee") == false ); |
224 | ai += 4; | ||
225 | unitTest( ai.compare("aoeu") == true ); | ||
226 | unitTest( ai.compare("aoeubo") == false ); | ||
227 | unitTest( ai.compare("aoe") == false ); | ||
228 | unitTest( ai.compare("wrong") == false ); | ||
229 | unitTest( ai.compare("boeu") == false ); | ||
213 | } | 230 | } |
214 | 231 | ||
215 | test iterator5 | 232 | test iteratorCompare4 |
216 | { | 233 | { |
217 | Bu::String a("1234aoeu"); | 234 | Bu::String a("1234aoeu"); |
218 | Bu::String::iterator ai = a.begin(); | 235 | Bu::String::iterator ai = a.begin(); |
@@ -221,7 +238,119 @@ suite String | |||
221 | unitTest( ai.compare("1234aoeuee", 10) == false ); | 238 | unitTest( ai.compare("1234aoeuee", 10) == false ); |
222 | } | 239 | } |
223 | 240 | ||
224 | test iterator6 | 241 | test iteratorCompare5 |
242 | { | ||
243 | Bu::String a("1234aoeu"); | ||
244 | Bu::String b("34ao"); | ||
245 | Bu::String::iterator ai = a.begin(); | ||
246 | unitTest( ai.compare( b ) == false ); | ||
247 | ai += 2; | ||
248 | unitTest( ai.compare( b ) == false ); | ||
249 | b = "oeu"; | ||
250 | ai += 3; | ||
251 | unitTest( ai.compare( b ) == true ); | ||
252 | b += "boo"; | ||
253 | unitTest( ai.compare( b ) == false ); | ||
254 | } | ||
255 | |||
256 | test iteratorCompare6 | ||
257 | { | ||
258 | Bu::String a("1234aoeu"); | ||
259 | Bu::String::iterator ai = a.begin(); | ||
260 | unitTest( ai.compare( Bu::String("1234"), 4) == true ); | ||
261 | unitTest( ai.compare( Bu::String("1234aoeu"), 8) == true ); | ||
262 | unitTest( ai.compare( Bu::String("1234aoeuee"), 10) == false ); | ||
263 | } | ||
264 | |||
265 | test const_iteratorCompare1 | ||
266 | { | ||
267 | Bu::String a("This is a test."); | ||
268 | Bu::String b("--This is a test."); | ||
269 | Bu::String::const_iterator ai = a.begin(); | ||
270 | Bu::String::const_iterator bi = b.begin(); | ||
271 | unitTest( ai.compare( bi ) == false ); | ||
272 | unitTest( bi.compare( ai ) == false ); | ||
273 | bi++; bi++; | ||
274 | unitTest( ai.compare( bi ) == true ); | ||
275 | unitTest( bi.compare( ai ) == true ); | ||
276 | b += "hi"; | ||
277 | unitTest( ai.compare( bi ) == false ); | ||
278 | unitTest( bi.compare( ai ) == false ); | ||
279 | } | ||
280 | |||
281 | test const_iteratorCompare2 | ||
282 | { | ||
283 | Bu::String a("1234honour"); | ||
284 | Bu::String b("--1234ueje"); | ||
285 | Bu::String::const_iterator ai = a.begin(); | ||
286 | Bu::String::const_iterator bi = b.begin(); | ||
287 | unitTest( ai.compare( bi, 4 ) == false ); | ||
288 | unitTest( bi.compare( ai, 4 ) == false ); | ||
289 | bi++; bi++; | ||
290 | unitTest( ai.compare( bi, 4 ) == true ); | ||
291 | unitTest( bi.compare( ai, 4 ) == true ); | ||
292 | unitTest( ai.compare( bi, 5 ) == false ); | ||
293 | unitTest( bi.compare( ai, 5 ) == false ); | ||
294 | |||
295 | a = "fell"; | ||
296 | b = "-felloo"; | ||
297 | ai = a.begin(); | ||
298 | bi = b.begin()+1; | ||
299 | unitTest( ai.compare( bi, 4 ) == true ); | ||
300 | ai++; | ||
301 | bi++; | ||
302 | unitTest( ai.compare( bi, 4 ) == false ); | ||
303 | } | ||
304 | |||
305 | test const_iteratorCompare3 | ||
306 | { | ||
307 | Bu::String a("1234aoeu"); | ||
308 | Bu::String::const_iterator ai = a.begin(); | ||
309 | unitTest( ai.compare("1234") == false ); | ||
310 | unitTest( ai.compare("1234aoeu") == true ); | ||
311 | unitTest( ai.compare("1234aoeuee") == false ); | ||
312 | ai += 4; | ||
313 | unitTest( ai.compare("aoeu") == true ); | ||
314 | unitTest( ai.compare("aoeubo") == false ); | ||
315 | unitTest( ai.compare("aoe") == false ); | ||
316 | unitTest( ai.compare("wrong") == false ); | ||
317 | unitTest( ai.compare("boeu") == false ); | ||
318 | } | ||
319 | |||
320 | test const_iteratorCompare4 | ||
321 | { | ||
322 | Bu::String a("1234aoeu"); | ||
323 | Bu::String::const_iterator ai = a.begin(); | ||
324 | unitTest( ai.compare("1234", 4) == true ); | ||
325 | unitTest( ai.compare("1234aoeu", 8) == true ); | ||
326 | unitTest( ai.compare("1234aoeuee", 10) == false ); | ||
327 | } | ||
328 | |||
329 | test const_iteratorCompare5 | ||
330 | { | ||
331 | Bu::String a("1234aoeu"); | ||
332 | Bu::String b("34ao"); | ||
333 | Bu::String::const_iterator ai = a.begin(); | ||
334 | unitTest( ai.compare( b ) == false ); | ||
335 | ai += 2; | ||
336 | unitTest( ai.compare( b ) == false ); | ||
337 | b = "oeu"; | ||
338 | ai += 3; | ||
339 | unitTest( ai.compare( b ) == true ); | ||
340 | b += "boo"; | ||
341 | unitTest( ai.compare( b ) == false ); | ||
342 | } | ||
343 | |||
344 | test const_iteratorCompare6 | ||
345 | { | ||
346 | Bu::String a("1234aoeu"); | ||
347 | Bu::String::const_iterator ai = a.begin(); | ||
348 | unitTest( ai.compare( Bu::String("1234"), 4) == true ); | ||
349 | unitTest( ai.compare( Bu::String("1234aoeu"), 8) == true ); | ||
350 | unitTest( ai.compare( Bu::String("1234aoeuee"), 10) == false ); | ||
351 | } | ||
352 | |||
353 | test iteratorAppend1 | ||
225 | { | 354 | { |
226 | Bu::String a("just ->this part"); | 355 | Bu::String a("just ->this part"); |
227 | Bu::String b; | 356 | Bu::String b; |
@@ -247,7 +376,7 @@ suite String | |||
247 | unitTest( c == b ); | 376 | unitTest( c == b ); |
248 | } | 377 | } |
249 | 378 | ||
250 | test iterator7 | 379 | test iteratorAppend2 |
251 | { | 380 | { |
252 | Bu::String a("just [this] part"); | 381 | Bu::String a("just [this] part"); |
253 | Bu::String b; | 382 | Bu::String b; |
@@ -428,6 +557,22 @@ suite String | |||
428 | unitTest( s1.toLower() == "hello there, how are you doing?" ); | 557 | unitTest( s1.toLower() == "hello there, how are you doing?" ); |
429 | unitTest( s1 == "HeLlO ThErE, HoW ArE YoU DoInG?" ); | 558 | unitTest( s1 == "HeLlO ThErE, HoW ArE YoU DoInG?" ); |
430 | } | 559 | } |
560 | |||
561 | test trimWhitespace1 | ||
562 | { | ||
563 | unitTest( Bu::String("Hello there").trimWhitespace() | ||
564 | == "Hello there" ); | ||
565 | unitTest( Bu::String(" \t\r\r\nHello there").trimWhitespace() | ||
566 | == "Hello there" ); | ||
567 | unitTest( Bu::String("Hello there \r\n\n\t\t ").trimWhitespace() | ||
568 | == "Hello there" ); | ||
569 | unitTest( Bu::String(" \tHello there\r\n \t").trimWhitespace() | ||
570 | == "Hello there" ); | ||
571 | unitTest( Bu::String(" \t\t\r\n").trimWhitespace() == "" ); | ||
572 | unitTest( Bu::String().trimWhitespace() == "" ); | ||
573 | unitTest( Bu::String(" \tHello \t\t\r\nthere\r\n \t").trimWhitespace() | ||
574 | == "Hello \t\t\r\nthere" ); | ||
575 | } | ||
431 | } | 576 | } |
432 | // 03F09CA4F58AC8CA0E80F0D9D409D0A60700A192270004BC3A99E91D0001034F544603362E35013103313130019CA4F58AC8CA0E0002830800002C4200008AC200EBF7D9D4090127BB010000E3 | 577 | // 03F09CA4F58AC8CA0E80F0D9D409D0A60700A192270004BC3A99E91D0001034F544603362E35013103313130019CA4F58AC8CA0E0002830800002C4200008AC200EBF7D9D4090127BB010000E3 |
433 | // | 578 | // |
@@ -1,6 +1,1377 @@ | |||
1 | {"test": | 1 | {"newVTR": |
2 | {repo: | 2 | //FONT DEFINITIONS |
3 | url = "http://svn.xagasoft.com/libbu++" | 3 | "basefontsize"="6pt" |
4 | name = libbu++ | 4 | {"font": |
5 | } | 5 | "name"="form_info" |
6 | "face"="Times New Roman" | ||
7 | "face"="Times" | ||
8 | "face"="serif" | ||
9 | "size"="{=basefontsize}" | ||
10 | } | ||
11 | {"font": | ||
12 | "name"="big_form_info" | ||
13 | "face"="Times New Roman" | ||
14 | "face"="Times" | ||
15 | "face"="serif" | ||
16 | "size"="{=basefontsize}+2pt" | ||
17 | "style"="bold" | ||
18 | } | ||
19 | {"font": | ||
20 | "name"="main_title" | ||
21 | "face"="Times New Roman" | ||
22 | "face"="Times" | ||
23 | "face"="serif" | ||
24 | "size"="{=basefontsize}+3.5pt" | ||
25 | "style"="bold" | ||
26 | } | ||
27 | {"font": | ||
28 | "name"="plain_title" | ||
29 | "face"="Times New Roman" | ||
30 | "face"="Times" | ||
31 | "face"="serif" | ||
32 | "size"="{=basefontsize}+3.5pt" | ||
33 | } | ||
34 | {"font": | ||
35 | "name"="italic_title" | ||
36 | "face"="Times New Roman" | ||
37 | "face"="Times" | ||
38 | "face"="serif" | ||
39 | "size"="{=basefontsize}+2pt" | ||
40 | "style"="italic" | ||
41 | } | ||
42 | {"font": | ||
43 | "name"="small_title" | ||
44 | "face"="Times New Roman" | ||
45 | "face"="Times" | ||
46 | "face"="serif" | ||
47 | "size"="{=basefontsize}-2pt" | ||
48 | } | ||
49 | {"font": | ||
50 | "name"="main_font" | ||
51 | "face"="Times New Roman" | ||
52 | "face"="Times" | ||
53 | "face"="serif" | ||
54 | "size"="{=basefontsize}" | ||
55 | "style"="bold" | ||
56 | } | ||
57 | {"font": | ||
58 | "name"="main_font_plain" | ||
59 | "face"="Times New Roman" | ||
60 | "face"="Times" | ||
61 | "face"="serif" | ||
62 | "size"="{=basefontsize}" | ||
63 | } | ||
64 | {"font": | ||
65 | "name"="big_font_bold" | ||
66 | "face"="Times New Roman" | ||
67 | "face"="Times" | ||
68 | "face"="serif" | ||
69 | "size"="{=basefontsize}+3.5pt" | ||
70 | "style"="bold" | ||
71 | } | ||
72 | {"font": | ||
73 | "name"="fill_in" | ||
74 | "face"="Courier New" | ||
75 | "face"="monospace" | ||
76 | "size"="{=basefontsize}+4pt" | ||
77 | "style"="bold" | ||
78 | } | ||
79 | {"font": | ||
80 | "name"="fill_in_med" | ||
81 | "face"="Courier New" | ||
82 | "face"="monospace" | ||
83 | "size"="{=basefontsize}+1pt" | ||
84 | "style"="bold" | ||
85 | } | ||
86 | {"font": | ||
87 | "name"="fill_in_sm" | ||
88 | "face"="Courier New" | ||
89 | "face"="monospace" | ||
90 | "size"="{=basefontsize}-0pt" | ||
91 | "style"="bold" | ||
92 | } | ||
93 | //DEFAULTS | ||
94 | {"default": | ||
95 | {"text": | ||
96 | "font"="main_font" | ||
97 | "alignment"="top" | ||
98 | } | ||
99 | } | ||
100 | //THE ACTUAL PAGE | ||
101 | {"page": | ||
102 | "name"="vtr_page" | ||
103 | "width"="8.5in" | ||
104 | "height"="11in" | ||
105 | "padding-left"=".3125in" | ||
106 | "padding-right"=".25in" | ||
107 | "padding-top"=".125in" | ||
108 | "padding-bottom"=".125in" | ||
109 | //FORM TITLE | ||
110 | {"box": | ||
111 | "name"="doc_header" | ||
112 | "width"="100%" | ||
113 | "height"=".3in" | ||
114 | {"text": | ||
115 | "string"="FISHING VESSEL TRIP REPORT" | ||
116 | "top"=".06in" | ||
117 | "font"="main_title" | ||
118 | "left"="2.8in" | ||
119 | } | ||
120 | } | ||
121 | //DID NOT FISH BOX | ||
122 | {"box": | ||
123 | "name"="did_not_fish" | ||
124 | "top"="doc_header::bottom" | ||
125 | "width"="3.2in" | ||
126 | "height"=".85in" | ||
127 | "thickness"="1pt" | ||
128 | "style"="solid" | ||
129 | {"text": | ||
130 | "top"="5pt" | ||
131 | "left"="1in" | ||
132 | "string"="DID NOT FISH" | ||
133 | "font"="plain_title" | ||
134 | } | ||
135 | {"box": | ||
136 | "name"="dnf_start" | ||
137 | "top"=".3in" | ||
138 | "width"="1.6in" | ||
139 | {"text": | ||
140 | "string"="Start Date" | ||
141 | "left"=".6in" | ||
142 | } | ||
143 | {"text": | ||
144 | "top"="14pt" | ||
145 | "left"=".35in" | ||
146 | "string"="______/______/______" | ||
147 | } | ||
148 | {"text": | ||
149 | "top"="24pt" | ||
150 | "left"=".35in" | ||
151 | "string"=" MM DD YY" | ||
152 | } | ||
153 | } | ||
154 | {"box": | ||
155 | "left"="dnf_start::right" | ||
156 | "top"=".3in" | ||
157 | {"text": | ||
158 | "string"="End Date" | ||
159 | "left"=".6in" | ||
160 | } | ||
161 | {"text": | ||
162 | "top"="14pt" | ||
163 | "left"=".35in" | ||
164 | "string"="______/______/______" | ||
165 | } | ||
166 | {"text": | ||
167 | "top"="24pt" | ||
168 | "left"=".35in" | ||
169 | "string"=" MM DD YY" | ||
170 | } | ||
171 | } | ||
172 | } | ||
173 | //FORM INFO (NUMBERS AND PERMIT, ETC) | ||
174 | {"box": | ||
175 | "name"="form_info" | ||
176 | "top"="doc_header::bottom" | ||
177 | "left"="did_not_fish::right" | ||
178 | "height"=".85in" | ||
179 | {"text": | ||
180 | "string"="NOAA Form No. 88-30" | ||
181 | "left"="3.6in" | ||
182 | "font"="form_info" | ||
183 | } | ||
184 | {"text": | ||
185 | "string"="OMB No. 0648-0212" | ||
186 | "top"="10pt" | ||
187 | "left"="3.71in" | ||
188 | "font"="form_info" | ||
189 | } | ||
190 | {"text": | ||
191 | "string"="Expires 1/31/2013" | ||
192 | "top"="20pt" | ||
193 | "left"="3.83in" | ||
194 | "font"="form_info" | ||
195 | } | ||
196 | {"text": | ||
197 | "top"=".6in" | ||
198 | "left"=".2in" | ||
199 | "src"="page_num" | ||
200 | "font"="main_title" | ||
201 | } | ||
202 | {"box": | ||
203 | "name"="permit" | ||
204 | "top"=".4in" | ||
205 | "left"="1.6in" | ||
206 | "width"="1in" | ||
207 | {"text": | ||
208 | "top"="5pt" | ||
209 | "string"="__________" | ||
210 | "font"="big_font_bold" | ||
211 | } | ||
212 | {"text": | ||
213 | "top"="19pt" | ||
214 | "string"=" PERMIT" | ||
215 | "font"="big_form_info" | ||
216 | } | ||
217 | //VESSEL PERMIT | ||
218 | {"text": | ||
219 | "top"="4pt" | ||
220 | "string"="FIXME" | ||
221 | "font"="fill_in" | ||
222 | "src"="rpt_permit" | ||
223 | } | ||
224 | } | ||
225 | {"box": | ||
226 | "name"="permit_year" | ||
227 | "top"=".4in" | ||
228 | "left"="permit::right" | ||
229 | "width"=".5in" | ||
230 | {"text": | ||
231 | "top"="5pt" | ||
232 | "string"="____" | ||
233 | "font"="big_font_bold" | ||
234 | } | ||
235 | {"text": | ||
236 | "top"="19pt" | ||
237 | "string"=" YY" | ||
238 | "font"="big_form_info" | ||
239 | } | ||
240 | //YEAR | ||
241 | {"text": | ||
242 | "top"="4pt" | ||
243 | "string"="FIXME" | ||
244 | "font"="fill_in" | ||
245 | "src"="rpt_year" | ||
246 | } | ||
247 | } | ||
248 | {"box": | ||
249 | "name"="permit_month" | ||
250 | "top"=".4in" | ||
251 | "left"="permit_year::right" | ||
252 | "width"=".5in" | ||
253 | {"text": | ||
254 | "top"="5pt" | ||
255 | "string"="____" | ||
256 | "font"="big_font_bold" | ||
257 | } | ||
258 | {"text": | ||
259 | "top"="19pt" | ||
260 | "string"=" MM" | ||
261 | "font"="big_form_info" | ||
262 | } | ||
263 | //MONTH | ||
264 | {"text": | ||
265 | "top"="4pt" | ||
266 | "string"="FIXME" | ||
267 | "font"="fill_in" | ||
268 | "src"="rpt_month" | ||
269 | } | ||
270 | } | ||
271 | {"box": | ||
272 | "name"="permit_day" | ||
273 | "top"=".4in" | ||
274 | "left"="permit_month::right" | ||
275 | "width"=".5in" | ||
276 | {"text": | ||
277 | "top"="5pt" | ||
278 | "string"="____" | ||
279 | "font"="big_font_bold" | ||
280 | } | ||
281 | {"text": | ||
282 | "top"="19pt" | ||
283 | "string"=" DD" | ||
284 | "font"="big_form_info" | ||
285 | } | ||
286 | //DAY | ||
287 | {"text": | ||
288 | "top"="4pt" | ||
289 | "string"="FIXME" | ||
290 | "font"="fill_in" | ||
291 | "src"="rpt_day" | ||
292 | } | ||
293 | } | ||
294 | {"box": | ||
295 | "name"="permit_hour" | ||
296 | "top"=".4in" | ||
297 | "left"="permit_day::right" | ||
298 | "width"=".5in" | ||
299 | {"text": | ||
300 | "top"="5pt" | ||
301 | "string"="____" | ||
302 | "font"="big_font_bold" | ||
303 | } | ||
304 | {"text": | ||
305 | "top"="19pt" | ||
306 | "string"=" HH" | ||
307 | "font"="big_form_info" | ||
308 | } | ||
309 | //HOUR | ||
310 | {"text": | ||
311 | "top"="4pt" | ||
312 | "string"="FIXME" | ||
313 | "font"="fill_in" | ||
314 | "src"="rpt_hour" | ||
315 | } | ||
316 | } | ||
317 | } | ||
318 | //HEADER LINE ONE | ||
319 | {"box": | ||
320 | "src"="trip_info" | ||
321 | "name"="header_line_1" | ||
322 | "top"="form_info::bottom+.2in" | ||
323 | "height"=".55in" | ||
324 | {"box": | ||
325 | "name"="vessel_name" | ||
326 | "width"="3in" | ||
327 | "thickness"="1pt" | ||
328 | "style"="solid" | ||
329 | {"text": | ||
330 | "top"="2pt" | ||
331 | "left"="5pt" | ||
332 | "string"="1. Vessel Name" | ||
333 | } | ||
334 | //VESSEL NAME | ||
335 | {"text": | ||
336 | "top"="16pt" | ||
337 | "left"=".2in" | ||
338 | "src"="vessel_name" | ||
339 | "font"="fill_in" | ||
340 | } | ||
341 | } | ||
342 | {"box": | ||
343 | "name"="doc_reg" | ||
344 | "left"="vessel_name::right" | ||
345 | "width"="2.5in" | ||
346 | "thickness"="1pt" | ||
347 | "style"="solid" | ||
348 | {"text": | ||
349 | "top"="2pt" | ||
350 | "left"="5pt" | ||
351 | "string"="2. USCG Documentation or State Registration" | ||
352 | } | ||
353 | //DOC REG | ||
354 | {"text": | ||
355 | "top"="16pt" | ||
356 | "left"=".2in" | ||
357 | "src"="doc_reg" | ||
358 | "font"="fill_in" | ||
359 | } | ||
360 | } | ||
361 | {"box": | ||
362 | "name"="permit" | ||
363 | "left"="doc_reg::right" | ||
364 | "thickness"="1pt" | ||
365 | "style"="solid" | ||
366 | {"text": | ||
367 | "top"="2pt" | ||
368 | "left"="5pt" | ||
369 | "string"="3. NMFS Vessel Permit Number" | ||
370 | } | ||
371 | //VESSEL PERMIT | ||
372 | {"text": | ||
373 | "top"="16pt" | ||
374 | "left"=".2in" | ||
375 | "src"="vessel_permit" | ||
376 | "font"="fill_in" | ||
377 | } | ||
378 | } | ||
379 | } | ||
380 | //HEADER LINE TWO | ||
381 | {"box": | ||
382 | "name"="header_line_2" | ||
383 | "top"="header_line_1::bottom" | ||
384 | "height"=".65in" | ||
385 | {"box": | ||
386 | "name"="date_sailed" | ||
387 | "width"="4in" | ||
388 | "thickness"="1pt" | ||
389 | "style"="solid" | ||
390 | {"text": | ||
391 | "top"="2pt" | ||
392 | "left"="5pt" | ||
393 | "string"="4. Date and Time Sailed" | ||
394 | } | ||
395 | {"text": | ||
396 | "top"=".36in" | ||
397 | "left"="5pt" | ||
398 | "string"="Date: ________/________/________" | ||
399 | "font"="main_font_plain" | ||
400 | } | ||
401 | //SAILED MM | ||
402 | {"text": | ||
403 | "top"=".28in" | ||
404 | "left"=".4in" | ||
405 | "string"="FIXME" | ||
406 | "font"="fill_in" | ||
407 | "src"="sailed_month" | ||
408 | } | ||
409 | //SAILED DD | ||
410 | {"text": | ||
411 | "top"=".28in" | ||
412 | "left"=".9in" | ||
413 | "string"="FIXME" | ||
414 | "font"="fill_in" | ||
415 | "src"="sailed_day" | ||
416 | } | ||
417 | //SAILED YY | ||
418 | {"text": | ||
419 | "top"=".28in" | ||
420 | "left"="1.4in" | ||
421 | "string"="FIXME" | ||
422 | "font"="fill_in" | ||
423 | "src"="sailed_year" | ||
424 | } | ||
425 | {"text": | ||
426 | "top"=".38in+8pt" | ||
427 | "left"="5pt+.4in" | ||
428 | "string"="MM DD YY" | ||
429 | "font"="main_font_plain" | ||
430 | } | ||
431 | {"text": | ||
432 | "top"=".36in" | ||
433 | "left"="2in+5pt" | ||
434 | "string"="Military Time: ________ : ________" | ||
435 | "font"="main_font_plain" | ||
436 | } | ||
437 | //SAILED TIME HH | ||
438 | {"text": | ||
439 | "top"=".28in" | ||
440 | "left"="2.9in" | ||
441 | "string"="FIXME" | ||
442 | "font"="fill_in" | ||
443 | "src"="sailed_hour" | ||
444 | } | ||
445 | //SAILED TIME MM | ||
446 | {"text": | ||
447 | "top"=".28in" | ||
448 | "left"="3.4in" | ||
449 | "string"="FIXME" | ||
450 | "font"="fill_in" | ||
451 | "src"="sailed_min" | ||
452 | } | ||
453 | {"text": | ||
454 | "top"=".38in+8pt" | ||
455 | "left"="2.4in+7pt+.4in" | ||
456 | "string"="HH MM" | ||
457 | "font"="main_font_plain" | ||
458 | } | ||
459 | } | ||
460 | {"box": | ||
461 | "name"="date_landed" | ||
462 | "left"="date_sailed::right" | ||
463 | "thickness"="1pt" | ||
464 | "style"="solid" | ||
465 | {"text": | ||
466 | "top"="2pt" | ||
467 | "left"="5pt" | ||
468 | "string"="5. Date and Time Landed" | ||
469 | } | ||
470 | {"text": | ||
471 | "top"=".36in" | ||
472 | "left"="5pt" | ||
473 | "string"="Date: ________/________/________" | ||
474 | "font"="main_font_plain" | ||
475 | } | ||
476 | //LANDED MM | ||
477 | {"text": | ||
478 | "top"=".28in" | ||
479 | "left"=".4in" | ||
480 | "string"="FIXME" | ||
481 | "font"="fill_in" | ||
482 | "src"="landed_month" | ||
483 | } | ||
484 | //LANDED DD | ||
485 | {"text": | ||
486 | "top"=".28in" | ||
487 | "left"=".9in" | ||
488 | "string"="FIXME" | ||
489 | "font"="fill_in" | ||
490 | "src"="landed_day" | ||
491 | } | ||
492 | //LANDED YY | ||
493 | {"text": | ||
494 | "top"=".28in" | ||
495 | "left"="1.4in" | ||
496 | "string"="FIXME" | ||
497 | "font"="fill_in" | ||
498 | "src"="landed_year" | ||
499 | } | ||
500 | {"text": | ||
501 | "top"=".38in+8pt" | ||
502 | "left"="5pt+.4in" | ||
503 | "string"="MM DD YY" | ||
504 | "font"="main_font_plain" | ||
505 | } | ||
506 | {"text": | ||
507 | "top"=".36in" | ||
508 | "left"="2in+5pt" | ||
509 | "string"="Military Time: ________ : ________" | ||
510 | "font"="main_font_plain" | ||
511 | } | ||
512 | //LANDED TIME HH | ||
513 | {"text": | ||
514 | "top"=".28in" | ||
515 | "left"="2.9in" | ||
516 | "string"="FIXME" | ||
517 | "font"="fill_in" | ||
518 | "src"="landed_hour" | ||
519 | } | ||
520 | //LANDED TIME MM | ||
521 | {"text": | ||
522 | "top"=".28in" | ||
523 | "left"="3.4in" | ||
524 | "string"="FIXME" | ||
525 | "font"="fill_in" | ||
526 | "src"="landed_min" | ||
527 | } | ||
528 | {"text": | ||
529 | "top"=".38in+8pt" | ||
530 | "left"="2.4in+7pt+.4in" | ||
531 | "string"="HH MM" | ||
532 | "font"="main_font_plain" | ||
533 | } | ||
534 | } | ||
535 | } | ||
536 | //HEADER LINE THREE | ||
537 | {"box": | ||
538 | "src"="trip_info" | ||
539 | "name"="header_line_3" | ||
540 | "top"="header_line_2::bottom" | ||
541 | "height"=".65in" | ||
542 | "thickness"="1pt" | ||
543 | "style"="solid" | ||
544 | {"text": | ||
545 | "top"="2pt" | ||
546 | "left"="5pt" | ||
547 | "string"="6. Trip Type - check one box and record the number of crew including the captain. Party/Charter must also include the number of anglers." | ||
548 | } | ||
549 | //COMERCIAL | ||
550 | {"box": | ||
551 | "name"="commercial" | ||
552 | "top"="14pt" | ||
553 | "left"="7pt" | ||
554 | "width"="2.2in" | ||
555 | {"box": | ||
556 | "name"="commercial_check" | ||
557 | "top"=".12in" | ||
558 | "height"=".2in" | ||
559 | "width"=".3in" | ||
560 | "thickness"="1pt" | ||
561 | "style"="solid" | ||
562 | //COMM CHECK | ||
563 | {"text": | ||
564 | "top"="1pt" | ||
565 | "left"=".1in" | ||
566 | "src"="tt_commercial" | ||
567 | "font"="fill_in" | ||
568 | } | ||
569 | } | ||
570 | {"text": | ||
571 | "top"="commercial_check::top+2pt" | ||
572 | "left"="commercial_check::right+2pt" | ||
573 | "string"="Commercial: # of Crew ________" | ||
574 | "font"="main_font_plain" | ||
575 | } | ||
576 | //COMM CrewNum | ||
577 | {"text": | ||
578 | "top"="commercial_check::top-3pt" | ||
579 | "left"="commercial_check::right+1.2in" | ||
580 | "src"="crew_no" | ||
581 | "font"="fill_in" | ||
582 | } | ||
583 | } | ||
584 | //RSAEFP | ||
585 | {"box": | ||
586 | "name"="rsaefp" | ||
587 | "top"="14pt" | ||
588 | "left"="commercial::right" | ||
589 | "width"="2.1in" | ||
590 | {"box": | ||
591 | "name"="rsaefp_check" | ||
592 | "top"=".12in" | ||
593 | "height"=".2in" | ||
594 | "width"=".3in" | ||
595 | "thickness"="1pt" | ||
596 | "style"="solid" | ||
597 | //rsaefp CHECK | ||
598 | {"text": | ||
599 | "top"="1pt" | ||
600 | "left"=".1in" | ||
601 | "string"="" | ||
602 | "font"="fill_in" | ||
603 | } | ||
604 | } | ||
605 | {"text": | ||
606 | "top"="rsaefp_check::top+2pt" | ||
607 | "left"="rsaefp_check::right+2pt" | ||
608 | "string"="RSA/EFP: # of Crew ________" | ||
609 | "font"="main_font_plain" | ||
610 | } | ||
611 | //RSAEFP CrewNum | ||
612 | {"text": | ||
613 | "top"="rsaefp_check::top-3pt" | ||
614 | "left"="rsaefp_check::right+1.1in" | ||
615 | "string"="" | ||
616 | // src="crew_no" | ||
617 | "font"="fill_in" | ||
618 | } | ||
619 | } | ||
620 | //PARTY | ||
621 | {"box": | ||
622 | "name"="party" | ||
623 | "top"="14pt" | ||
624 | "left"="rsaefp::right" | ||
625 | "width"="1.8in" | ||
626 | {"box": | ||
627 | "name"="party_check" | ||
628 | "top"=".12in" | ||
629 | "height"=".2in" | ||
630 | "width"=".3in" | ||
631 | "thickness"="1pt" | ||
632 | "style"="solid" | ||
633 | //party CHECK | ||
634 | {"text": | ||
635 | "top"="1pt" | ||
636 | "left"=".1in" | ||
637 | "src"="tt_party" | ||
638 | "font"="fill_in" | ||
639 | } | ||
640 | } | ||
641 | {"text": | ||
642 | "top"="party_check::top+2pt" | ||
643 | "left"="party_check::right+2pt" | ||
644 | "string"="Party:" | ||
645 | "font"="main_font_plain" | ||
646 | } | ||
647 | {"text": | ||
648 | "top"="5pt" | ||
649 | "left"="party_check::right+.3in" | ||
650 | "string"="# of Crew ______" | ||
651 | "font"="main_font_plain" | ||
652 | } | ||
653 | //Party CrewNum | ||
654 | {"text": | ||
655 | "top"="-1pt" | ||
656 | "left"="party_check::right+.9in" | ||
657 | "string"="" | ||
658 | // src="crew_no" | ||
659 | "font"="fill_in" | ||
660 | } | ||
661 | {"text": | ||
662 | "top"=".25in" | ||
663 | "left"="party_check::right+.3in" | ||
664 | "string"="# of Anglers ______" | ||
665 | "font"="main_font_plain" | ||
666 | } | ||
667 | //Party Anglers | ||
668 | {"text": | ||
669 | "top"=".24in-3pt" | ||
670 | "left"="party_check::right+.9in" | ||
671 | "string"="" | ||
672 | // src="angler_no" | ||
673 | "font"="fill_in" | ||
674 | } | ||
675 | } | ||
676 | //CHARTER | ||
677 | {"box": | ||
678 | "name"="charter" | ||
679 | "top"="14pt" | ||
680 | "left"="party::right" | ||
681 | //width=2.2in | ||
682 | {"box": | ||
683 | "name"="charter_check" | ||
684 | "top"=".12in" | ||
685 | "height"=".2in" | ||
686 | "width"=".3in" | ||
687 | "thickness"="1pt" | ||
688 | "style"="solid" | ||
689 | //charter CHECK | ||
690 | {"text": | ||
691 | "top"="1pt" | ||
692 | "left"=".1in" | ||
693 | "src"="tt_charter" | ||
694 | "font"="fill_in" | ||
695 | } | ||
696 | } | ||
697 | {"text": | ||
698 | "top"="charter_check::top+2pt" | ||
699 | "left"="charter_check::right+2pt" | ||
700 | "string"="Charter:" | ||
701 | "font"="main_font_plain" | ||
702 | } | ||
703 | {"text": | ||
704 | "top"="5pt" | ||
705 | "left"="charter_check::right+.3in" | ||
706 | "string"="# of Crew ______" | ||
707 | "font"="main_font_plain" | ||
708 | } | ||
709 | //Party CrewNum | ||
710 | {"text": | ||
711 | "top"="-1pt" | ||
712 | "left"="charter_check::right+.9in" | ||
713 | "string"="" | ||
714 | // src="crew_no" | ||
715 | "font"="fill_in" | ||
716 | } | ||
717 | {"text": | ||
718 | "top"=".25in" | ||
719 | "left"="charter_check::right+.3in" | ||
720 | "string"="# of Anglers ______" | ||
721 | "font"="main_font_plain" | ||
722 | } | ||
723 | //Party Anglers | ||
724 | {"text": | ||
725 | "top"=".24in-3pt" | ||
726 | "left"="charter_check::right+.9in" | ||
727 | "string"="" | ||
728 | // src="angler_no" | ||
729 | "font"="fill_in" | ||
730 | } | ||
731 | } | ||
732 | } | ||
733 | //INSTRUCTIONS | ||
734 | {"box": | ||
735 | "name"="instructions" | ||
736 | "top"="header_line_3::bottom" | ||
737 | "height"=".5in" | ||
738 | {"text": | ||
739 | "top"=".15in" | ||
740 | "left"=".1in" | ||
741 | "string"="COMPLETE A NEW FORM FOR EACH DIFFERENT CHART AREA, GEAR TYPE OR MESH/RING SIZE USED ON A TRIP." | ||
742 | "font"="italic_title" | ||
743 | } | ||
744 | } | ||
745 | //DATA_LINE_1 | ||
746 | {"box": | ||
747 | "src"="setup_info" | ||
748 | "name"="data_line_1" | ||
749 | "top"="instructions::bottom" | ||
750 | "height"=".55in" | ||
751 | {"box": | ||
752 | "name"="gear_code" | ||
753 | "width"="1.3in" | ||
754 | "thickness"="1pt" | ||
755 | "style"="solid" | ||
756 | {"text": | ||
757 | "top"="2pt" | ||
758 | "left"="5pt" | ||
759 | "string"="7. Gear Code" | ||
760 | } | ||
761 | //GEAR CODE | ||
762 | {"text": | ||
763 | "top"="16pt" | ||
764 | "left"=".2in" | ||
765 | "src"="gear" | ||
766 | "font"="fill_in" | ||
767 | } | ||
768 | } | ||
769 | {"box": | ||
770 | "name"="meshring_size" | ||
771 | "left"="gear_code::right" | ||
772 | "width"="1.25in" | ||
773 | "thickness"="1pt" | ||
774 | "style"="solid" | ||
775 | {"text": | ||
776 | "top"="2pt" | ||
777 | "left"="5pt" | ||
778 | "string"="8. Mesh/Ring Size" | ||
779 | } | ||
780 | //MESHRING SIZE | ||
781 | {"text": | ||
782 | "top"="16pt" | ||
783 | "left"=".2in" | ||
784 | "src"="mesh_ring_size" | ||
785 | "font"="fill_in" | ||
786 | } | ||
787 | } | ||
788 | {"box": | ||
789 | "name"="quantity" | ||
790 | "left"="meshring_size::right" | ||
791 | "width"="1.25in" | ||
792 | "thickness"="1pt" | ||
793 | "style"="solid" | ||
794 | {"text": | ||
795 | "top"="2pt" | ||
796 | "left"="5pt" | ||
797 | "string"="9. Gear Quantity" | ||
798 | } | ||
799 | //GEAR QUANTITY | ||
800 | {"text": | ||
801 | "top"="16pt" | ||
802 | "left"=".2in" | ||
803 | "src"="gear_num" | ||
804 | "font"="fill_in" | ||
805 | } | ||
806 | } | ||
807 | {"box": | ||
808 | "name"="size" | ||
809 | "left"="quantity::right" | ||
810 | "width"="1.25in" | ||
811 | "thickness"="1pt" | ||
812 | "style"="solid" | ||
813 | {"text": | ||
814 | "top"="2pt" | ||
815 | "left"="5pt" | ||
816 | "string"="10. Gear Size" | ||
817 | } | ||
818 | //GEAR SIZE | ||
819 | {"text": | ||
820 | "top"="16pt" | ||
821 | "left"=".2in" | ||
822 | "src"="gear_size" | ||
823 | "font"="fill_in" | ||
824 | } | ||
825 | } | ||
826 | {"box": | ||
827 | "name"="depth" | ||
828 | "left"="size::right" | ||
829 | "width"="1.5in" | ||
830 | "thickness"="1pt" | ||
831 | "style"="solid" | ||
832 | {"text": | ||
833 | "top"="2pt" | ||
834 | "left"="5pt" | ||
835 | "string"="11. Fishing Depth (Fathoms)" | ||
836 | } | ||
837 | //FISHING DEPTH | ||
838 | {"text": | ||
839 | "top"="16pt" | ||
840 | "left"=".2in" | ||
841 | "src"="depth" | ||
842 | "font"="fill_in" | ||
843 | } | ||
844 | } | ||
845 | {"box": | ||
846 | "name"="hauls" | ||
847 | "left"="depth::right" | ||
848 | "thickness"="1pt" | ||
849 | "style"="solid" | ||
850 | {"text": | ||
851 | "top"="2pt" | ||
852 | "left"="5pt" | ||
853 | "string"="12. Number of Hauls" | ||
854 | } | ||
855 | //HAUL NO | ||
856 | {"text": | ||
857 | "top"="16pt" | ||
858 | "left"=".2in" | ||
859 | "src"="haul_no" | ||
860 | "font"="fill_in" | ||
861 | } | ||
862 | } | ||
863 | } | ||
864 | //DATA_LINE_2 | ||
865 | {"box": | ||
866 | "src"="setup_info" | ||
867 | "name"="data_line_2" | ||
868 | "top"="data_line_1::bottom" | ||
869 | "height"=".55in" | ||
870 | {"box": | ||
871 | "name"="chart_area" | ||
872 | "width"="1.2in" | ||
873 | "thickness"="1pt" | ||
874 | "style"="solid" | ||
875 | {"text": | ||
876 | "top"="2pt" | ||
877 | "left"="5pt" | ||
878 | "string"="13. Chart Area" | ||
879 | } | ||
880 | //CHART AREA | ||
881 | {"text": | ||
882 | "top"="16pt" | ||
883 | "left"=".2in" | ||
884 | "src"="chart_area" | ||
885 | "font"="fill_in" | ||
886 | } | ||
887 | } | ||
888 | {"box": | ||
889 | "name"="latitude" | ||
890 | "left"="chart_area::right" | ||
891 | "width"="2.2in" | ||
892 | "thickness"="1pt" | ||
893 | "style"="solid" | ||
894 | {"text": | ||
895 | "top"="2pt" | ||
896 | "left"="5pt" | ||
897 | "string"="14. Latitude" | ||
898 | } | ||
899 | {"text": | ||
900 | "top"=".25in" | ||
901 | "left"=".4in" | ||
902 | "string"="_____________:_____________" | ||
903 | "font"="main_font_plain" | ||
904 | } | ||
905 | //LAT DEG | ||
906 | {"text": | ||
907 | "top"="12pt" | ||
908 | "left"=".6in" | ||
909 | "string"="FIXME" | ||
910 | "font"="fill_in" | ||
911 | "src"="lat_hour" | ||
912 | } | ||
913 | //LAT MIN | ||
914 | {"text": | ||
915 | "top"="12pt" | ||
916 | "left"="1.4in" | ||
917 | "string"="FIXME" | ||
918 | "font"="fill_in" | ||
919 | "src"="lat_min" | ||
920 | } | ||
921 | {"text": | ||
922 | "top"=".25in+10pt" | ||
923 | "left"=".5in" | ||
924 | "string"="DEGREES MINUTES" | ||
925 | "font"="main_font_plain" | ||
926 | } | ||
927 | } | ||
928 | {"box": | ||
929 | "name"="longitude" | ||
930 | "left"="latitude::right" | ||
931 | "width"="2.2in" | ||
932 | "thickness"="1pt" | ||
933 | "style"="solid" | ||
934 | {"text": | ||
935 | "top"="2pt" | ||
936 | "left"="5pt" | ||
937 | "string"="15. Longitude" | ||
938 | } | ||
939 | {"text": | ||
940 | "top"=".25in" | ||
941 | "left"=".4in" | ||
942 | "string"="_____________:_____________" | ||
943 | "font"="main_font_plain" | ||
944 | } | ||
945 | //LON DEG | ||
946 | {"text": | ||
947 | "top"="12pt" | ||
948 | "left"=".6in" | ||
949 | "string"="FIXME" | ||
950 | "font"="fill_in" | ||
951 | "src"="lon_hour" | ||
952 | } | ||
953 | //LON MIN | ||
954 | {"text": | ||
955 | "top"="12pt" | ||
956 | "left"="1.4in" | ||
957 | "string"="FIXME" | ||
958 | "font"="fill_in" | ||
959 | "src"="lon_min" | ||
960 | } | ||
961 | {"text": | ||
962 | "top"=".25in+10pt" | ||
963 | "left"=".5in" | ||
964 | "string"="DEGREES MINUTES" | ||
965 | "font"="main_font_plain" | ||
966 | } | ||
967 | } | ||
968 | {"box": | ||
969 | "name"="towsoak_time" | ||
970 | "left"="longitude::right" | ||
971 | "thickness"="1pt" | ||
972 | "style"="solid" | ||
973 | {"text": | ||
974 | "top"="2pt" | ||
975 | "left"="5pt" | ||
976 | "string"="16. Tow / Soak Time" | ||
977 | } | ||
978 | {"text": | ||
979 | "top"=".25in" | ||
980 | "left"=".4in" | ||
981 | "string"="_____________:_____________" | ||
982 | "font"="main_font_plain" | ||
983 | } | ||
984 | //SOAK HR | ||
985 | {"text": | ||
986 | "top"="12pt" | ||
987 | "left"=".6in" | ||
988 | "src"="tow_soak_time_hrs" | ||
989 | "font"="fill_in" | ||
990 | } | ||
991 | //SOAK MIN | ||
992 | {"text": | ||
993 | "top"="12pt" | ||
994 | "left"="1.4in" | ||
995 | "src"="tow_soak_time_mins" | ||
996 | "font"="fill_in" | ||
997 | } | ||
998 | {"text": | ||
999 | "top"=".25in+10pt" | ||
1000 | "left"=".5in" | ||
1001 | "string"="HOURS MINUTES" | ||
1002 | "font"="main_font_plain" | ||
1003 | } | ||
1004 | } | ||
1005 | } | ||
1006 | //DATA_LINE_3 | ||
1007 | {"box": | ||
1008 | "name"="data_line_3" | ||
1009 | "top"="data_line_2::bottom" | ||
1010 | "height"=".4in" | ||
1011 | {"box": | ||
1012 | "name"="species" | ||
1013 | "width"=".9in" | ||
1014 | "thickness"="1pt" | ||
1015 | "style"="solid" | ||
1016 | {"text": | ||
1017 | "top"="2pt" | ||
1018 | "left"=".45in" | ||
1019 | "string"="17." | ||
1020 | } | ||
1021 | {"text": | ||
1022 | "top"="11pt" | ||
1023 | "left"="15pt" | ||
1024 | "string"="Species Code" | ||
1025 | } | ||
1026 | } | ||
1027 | {"box": | ||
1028 | "name"="kept" | ||
1029 | "left"="species::right" | ||
1030 | "width"=".9in" | ||
1031 | "thickness"="1pt" | ||
1032 | "style"="solid" | ||
1033 | {"text": | ||
1034 | "top"="2pt" | ||
1035 | "left"=".45in" | ||
1036 | "string"="18." | ||
1037 | } | ||
1038 | {"text": | ||
1039 | "top"="11pt" | ||
1040 | "left"=".3in" | ||
1041 | "string"="Kept" | ||
1042 | } | ||
1043 | } | ||
1044 | {"box": | ||
1045 | "name"="discarded" | ||
1046 | "left"="kept::right" | ||
1047 | "width"=".9in" | ||
1048 | "thickness"="1pt" | ||
1049 | "style"="solid" | ||
1050 | {"text": | ||
1051 | "top"="2pt" | ||
1052 | "left"="5pt" | ||
1053 | "string"="19. Discarded" | ||
1054 | } | ||
1055 | } | ||
1056 | {"box": | ||
1057 | "name"="dealer_permit" | ||
1058 | "left"="discarded::right" | ||
1059 | "width"=".7in" | ||
1060 | "thickness"="1pt" | ||
1061 | "style"="solid" | ||
1062 | {"text": | ||
1063 | "top"="2pt" | ||
1064 | "left"="8pt" | ||
1065 | "string"="20. Dealer" | ||
1066 | } | ||
1067 | {"text": | ||
1068 | "top"="10pt" | ||
1069 | "left"="12pt" | ||
1070 | "string"="Permit" | ||
1071 | } | ||
1072 | {"text": | ||
1073 | "top"="18pt" | ||
1074 | "left"="10pt" | ||
1075 | "string"="Number" | ||
1076 | } | ||
1077 | } | ||
1078 | {"box": | ||
1079 | "name"="dealer_name" | ||
1080 | "left"="dealer_permit::right" | ||
1081 | "width"="1.8in" | ||
1082 | "thickness"="1pt" | ||
1083 | "style"="solid" | ||
1084 | {"text": | ||
1085 | "top"="2pt" | ||
1086 | "left"=".7in" | ||
1087 | "string"="21." | ||
1088 | } | ||
1089 | {"text": | ||
1090 | "top"="11pt" | ||
1091 | "left"=".5in" | ||
1092 | "string"="Dealer Name" | ||
1093 | } | ||
1094 | } | ||
1095 | {"box": | ||
1096 | "name"="date_sold" | ||
1097 | "left"="dealer_name::right" | ||
1098 | "width"=".75in" | ||
1099 | "thickness"="1pt" | ||
1100 | "style"="solid" | ||
1101 | {"text": | ||
1102 | "top"="2pt" | ||
1103 | "left"=".3in" | ||
1104 | "string"="22." | ||
1105 | } | ||
1106 | {"text": | ||
1107 | "top"="10pt" | ||
1108 | "left"="10pt" | ||
1109 | "string"="Date Sold" | ||
1110 | } | ||
1111 | {"text": | ||
1112 | "top"="18pt" | ||
1113 | "left"="7pt" | ||
1114 | "string"="MM/DD/YY" | ||
1115 | } | ||
1116 | } | ||
1117 | {"box": | ||
1118 | "name"="offload_port" | ||
1119 | "left"="date_sold::right" | ||
1120 | "thickness"="1pt" | ||
1121 | "style"="solid" | ||
1122 | {"text": | ||
1123 | "top"="1pt" | ||
1124 | "left"="5pt" | ||
1125 | "string"="23. Offloading Port for each species" | ||
1126 | } | ||
1127 | {"line": | ||
1128 | "top"="11pt" | ||
1129 | "bottom"="11pt" | ||
1130 | "thickness"="1pt" | ||
1131 | "style"="solid" | ||
1132 | } | ||
1133 | {"text": | ||
1134 | "top"="12pt" | ||
1135 | "left"=".6in" | ||
1136 | "string"="City" | ||
1137 | } | ||
1138 | {"line": | ||
1139 | "top"="11pt" | ||
1140 | "left"="1.5in" | ||
1141 | "right"="1.5in" | ||
1142 | } | ||
1143 | {"text": | ||
1144 | "top"="12pt" | ||
1145 | "left"="1.6in" | ||
1146 | "string"="State" | ||
1147 | } | ||
1148 | } | ||
1149 | } | ||
1150 | //DATA_GRID | ||
1151 | {"box": | ||
1152 | "name"="data_grid" | ||
1153 | "top"="data_line_3::bottom" | ||
1154 | "height"="4.25in" | ||
1155 | "src"="setup_info" | ||
1156 | {"box": | ||
1157 | "src"="catch_data" | ||
1158 | "repeat"="tile-ttb-ltr" | ||
1159 | "height"=".3in" | ||
1160 | {"box": | ||
1161 | "name"="data_species" | ||
1162 | "width"=".9in" | ||
1163 | "thickness"="1pt" | ||
1164 | "style"="solid" | ||
1165 | //SPECIES | ||
1166 | {"text": | ||
1167 | "top"="2pt" | ||
1168 | "left"=".1in" | ||
1169 | "src"="species_code" | ||
1170 | "font"="fill_in" | ||
1171 | } | ||
1172 | } | ||
1173 | {"box": | ||
1174 | "name"="data_kept" | ||
1175 | "left"="data_species::right" | ||
1176 | "width"=".9in" | ||
1177 | "thickness"="1pt" | ||
1178 | "style"="solid" | ||
1179 | //KEPT | ||
1180 | {"text": | ||
1181 | "top"="2pt" | ||
1182 | "left"=".1in" | ||
1183 | "src"="kept_pounds" | ||
1184 | "font"="fill_in" | ||
1185 | } | ||
1186 | } | ||
1187 | {"box": | ||
1188 | "name"="data_discarded" | ||
1189 | "left"="data_kept::right" | ||
1190 | "width"=".9in" | ||
1191 | "thickness"="1pt" | ||
1192 | "style"="solid" | ||
1193 | //DISC | ||
1194 | {"text": | ||
1195 | "top"="2pt" | ||
1196 | "left"=".1in" | ||
1197 | "src"="disc_pounds" | ||
1198 | "font"="fill_in" | ||
1199 | } | ||
1200 | } | ||
1201 | {"box": | ||
1202 | "name"="data_dealer_permit" | ||
1203 | "left"="data_discarded::right" | ||
1204 | "width"=".7in" | ||
1205 | "thickness"="1pt" | ||
1206 | "style"="solid" | ||
1207 | //DEALER_NUM | ||
1208 | {"text": | ||
1209 | "top"="5pt" | ||
1210 | "left"="5pt" | ||
1211 | "src"="dealer_no" | ||
1212 | "font"="fill_in_med" | ||
1213 | } | ||
1214 | } | ||
1215 | {"box": | ||
1216 | "name"="data_dealer_name" | ||
1217 | "left"="data_dealer_permit::right" | ||
1218 | "width"="1.8in" | ||
1219 | "thickness"="1pt" | ||
1220 | "style"="solid" | ||
1221 | //DEALER NAME | ||
1222 | {"text": | ||
1223 | "top"="1pt" | ||
1224 | "left"="5pt" | ||
1225 | "src"="dealer_name" | ||
1226 | "font"="fill_in_sm" | ||
1227 | } | ||
1228 | } | ||
1229 | {"box": | ||
1230 | "name"="data_date_sold" | ||
1231 | "left"="data_dealer_name::right" | ||
1232 | "width"=".75in" | ||
1233 | "thickness"="1pt" | ||
1234 | "style"="solid" | ||
1235 | //DATE SOLD | ||
1236 | {"text": | ||
1237 | "top"="5pt" | ||
1238 | "left"="2pt" | ||
1239 | "src"="date_sold" | ||
1240 | "font"="fill_in_med" | ||
1241 | } | ||
1242 | } | ||
1243 | {"box": | ||
1244 | "name"="data_port_city" | ||
1245 | "left"="data_date_sold::right" | ||
1246 | "width"="1.5in" | ||
1247 | "thickness"="1pt" | ||
1248 | "style"="solid" | ||
1249 | //PORT CITY | ||
1250 | {"text": | ||
1251 | "top"="5pt" | ||
1252 | "left"="5pt" | ||
1253 | "src"="port_city" | ||
1254 | "font"="fill_in_med" | ||
1255 | } | ||
1256 | } | ||
1257 | {"box": | ||
1258 | "name"="data_port_state" | ||
1259 | "left"="data_port_city::right" | ||
1260 | "thickness"="1pt" | ||
1261 | "style"="solid" | ||
1262 | //PORT STATE | ||
1263 | {"text": | ||
1264 | "top"="2pt" | ||
1265 | "left"=".1in" | ||
1266 | "src"="port_state" | ||
1267 | "font"="fill_in" | ||
1268 | } | ||
1269 | } | ||
1270 | } | ||
1271 | } | ||
1272 | //WARNING | ||
1273 | {"box": | ||
1274 | "name"="warning" | ||
1275 | "top"="data_grid::bottom" | ||
1276 | "height"="14pt" | ||
1277 | {"text": | ||
1278 | "top"="2pt" | ||
1279 | "left"=".5in" | ||
1280 | "string"="I certify that the information provided on this form is true, complete and correct to the best of my knowledge, and made in good faith. Making a false statement on this form is punishable by law (18 U.S.C. 1001)." | ||
1281 | "font"="small_title" | ||
1282 | } | ||
1283 | } | ||
1284 | //SIGN | ||
1285 | {"box": | ||
1286 | "name"="sign" | ||
1287 | "top"="warning::bottom" | ||
1288 | "height"=".5in" | ||
1289 | "src"="sign_info" | ||
1290 | {"box": | ||
1291 | "name"="op_permit" | ||
1292 | "width"="1.8in" | ||
1293 | "thickness"="1pt" | ||
1294 | "style"="solid" | ||
1295 | {"text": | ||
1296 | "top"="2pt" | ||
1297 | "left"="5pt" | ||
1298 | "string"="24. Operator Permit Number" | ||
1299 | } | ||
1300 | //OP PERMIT | ||
1301 | {"text": | ||
1302 | "top"="16pt" | ||
1303 | "left"=".1in" | ||
1304 | "string"="FIXME" | ||
1305 | "font"="fill_in" | ||
1306 | "src"="operator_permit" | ||
1307 | } | ||
1308 | } | ||
1309 | {"box": | ||
1310 | "name"="op_name" | ||
1311 | "left"="op_permit::right" | ||
1312 | "width"="2.4in" | ||
1313 | "thickness"="1pt" | ||
1314 | "style"="solid" | ||
1315 | {"text": | ||
1316 | "top"="2pt" | ||
1317 | "left"="5pt" | ||
1318 | "string"="25. Operator Name" | ||
1319 | } | ||
1320 | //OP PERMIT | ||
1321 | {"text": | ||
1322 | "top"="16pt" | ||
1323 | "left"=".1in" | ||
1324 | "string"="FIXME" | ||
1325 | "font"="fill_in" | ||
1326 | "src"="operator_name" | ||
1327 | } | ||
1328 | } | ||
1329 | {"box": | ||
1330 | "name"="op_sig" | ||
1331 | "left"="op_name::right" | ||
1332 | "width"="2.4in" | ||
1333 | "thickness"="1pt" | ||
1334 | "style"="solid" | ||
1335 | {"text": | ||
1336 | "top"="2pt" | ||
1337 | "left"="5pt" | ||
1338 | "string"="26. Operator Signature" | ||
1339 | } | ||
1340 | } | ||
1341 | {"box": | ||
1342 | "name"="op_date" | ||
1343 | "left"="op_sig::right" | ||
1344 | "thickness"="1pt" | ||
1345 | "style"="solid" | ||
1346 | {"text": | ||
1347 | "top"="2pt" | ||
1348 | "left"="5pt" | ||
1349 | "string"="27. Date Signed" | ||
1350 | } | ||
1351 | {"text": | ||
1352 | "top"="10pt" | ||
1353 | "left"=".4in" | ||
1354 | "string"="MM/DD/YY" | ||
1355 | } | ||
1356 | //DATE SIGNED | ||
1357 | {"text": | ||
1358 | "top"="20pt" | ||
1359 | "left"=".1in" | ||
1360 | "src"="sig_date" | ||
1361 | "font"="fill_in" | ||
1362 | } | ||
1363 | } | ||
1364 | } | ||
1365 | //BOTTOM | ||
1366 | {"box": | ||
1367 | "name"="bottom" | ||
1368 | "top"="sign::bottom" | ||
1369 | {"text": | ||
1370 | "top"=".3in" | ||
1371 | "left"="3.5in" | ||
1372 | "string"="NMFS COPY" | ||
1373 | "font"="main_title" | ||
1374 | } | ||
1375 | } | ||
1376 | } | ||
6 | } | 1377 | } |