Inside Bitcoin

1001    BOOST_CHECK(!ParseFixedPoint("1.1e-", 8, &amount));
1002    BOOST_CHECK(!ParseFixedPoint("1.", 8, &amount));
1003
1004    // Test with 3 decimal places for fee rates in sat/vB.
1005    BOOST_CHECK(ParseFixedPoint("0.001", 3, &amount));
1006    BOOST_CHECK_EQUAL(amount, CAmount{1});
1007    BOOST_CHECK(!ParseFixedPoint("0.0009", 3, &amount));
1008    BOOST_CHECK(!ParseFixedPoint("31.00100001", 3, &amount));
1009    BOOST_CHECK(!ParseFixedPoint("31.0011", 3, &amount));
1010    BOOST_CHECK(!ParseFixedPoint("31.99999999", 3, &amount));
1011    BOOST_CHECK(!ParseFixedPoint("31.999999999999999999999", 3, &amount));
1012}
1013
1014#ifndef WIN32 // Cannot do this test on WIN32 due to lack of fork()
1015static constexpr char LockCommand = 'L';
1016static constexpr char UnlockCommand = 'U';
1017static constexpr char ExitCommand = 'X';
1018enum : char {
1019    ResSuccess = 2, // Start with 2 to avoid accidental collision with common values 0 and 1
1020    ResErrorWrite,
1021    ResErrorLock,
1022    ResUnlockSuccess,
1023};
1024
1025[[noreturn]] static void TestOtherProcess(fs::path dirname, fs::path lockname, int fd)
1026{
1027    char ch;
1028    while (true) {
1029        int rv = read(fd, &ch, 1); // Wait for command
1030        assert(rv == 1);
1031        switch (ch) {
1032        case LockCommand:
1033            ch = [&] {
1034                switch (util::LockDirectory(dirname, lockname)) {
1035                case util::LockResult::Success: return ResSuccess;
1036                case util::LockResult::ErrorWrite: return ResErrorWrite;
1037                case util::LockResult::ErrorLock: return ResErrorLock;
1038                } // no default case, so the compiler can warn about missing cases
1039                assert(false);
1040            }();
1041            rv = write(fd, &ch, 1);
1042            assert(rv == 1);
1043            break;
1044        case UnlockCommand:
1045            ReleaseDirectoryLocks();
1046            ch = ResUnlockSuccess; // Always succeeds
1047            rv = write(fd, &ch, 1);
1048            assert(rv == 1);
1049            break;
1050        case ExitCommand:
1051            close(fd);
1052            exit(0);
1053        default:
1054            assert(0);
1055        }
1056    }
1057}
1058#endif
1059
1060BOOST_AUTO_TEST_CASE(test_LockDirectory)
1061{
1062    fs::path dirname = m_args.GetDataDirBase() / "lock_dir";
1063    const fs::path lockname = ".lock";
1064#ifndef WIN32
1065    // Fork another process for testing before creating the lock, so that we
1066    // won't fork while holding the lock (which might be undefined, and is not
1067    // relevant as test case as that is avoided with -daemonize).
1068    int fd[2];
1069    BOOST_CHECK_EQUAL(socketpair(AF_UNIX, SOCK_STREAM, 0, fd), 0);
1070    pid_t pid = fork();
1071    if (!pid) {
1072        BOOST_CHECK_EQUAL(close(fd[1]), 0); // Child: close parent end
1073        TestOtherProcess(dirname, lockname, fd[0]);
1074    }
1075    BOOST_CHECK_EQUAL(close(fd[0]), 0); // Parent: close child end
1076
1077    char ch;
1078    // Lock on non-existent directory should fail
1079    BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
1080    BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
1081    BOOST_CHECK_EQUAL(ch, ResErrorWrite);
1082#endif
1083    // Lock on non-existent directory should fail
1084    BOOST_CHECK_EQUAL(util::LockDirectory(dirname, lockname), util::LockResult::ErrorWrite);
1085
1086    fs::create_directories(dirname);
1087
1088    // Probing lock on new directory should succeed
1089    BOOST_CHECK_EQUAL(util::LockDirectory(dirname, lockname, true), util::LockResult::Success);
1090
1091    // Persistent lock on new directory should succeed
1092    BOOST_CHECK_EQUAL(util::LockDirectory(dirname, lockname), util::LockResult::Success);
1093
1094    // Another lock on the directory from the same thread should succeed
1095    BOOST_CHECK_EQUAL(util::LockDirectory(dirname, lockname), util::LockResult::Success);
1096
1097    // Another lock on the directory from a different thread within the same process should succeed
1098    util::LockResult threadresult;
1099    std::thread thr([&] { threadresult = util::LockDirectory(dirname, lockname); });
1100    thr.join();
1101    BOOST_CHECK_EQUAL(threadresult, util::LockResult::Success);
1102#ifndef WIN32
1103    // Try to acquire lock in child process while we're holding it, this should fail.
1104    BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
1105    BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
1106    BOOST_CHECK_EQUAL(ch, ResErrorLock);
1107
1108    // Give up our lock
1109    ReleaseDirectoryLocks();
1110    // Probing lock from our side now should succeed, but not hold on to the lock.
1111    BOOST_CHECK_EQUAL(util::LockDirectory(dirname, lockname, true), util::LockResult::Success);
1112
1113    // Try to acquire the lock in the child process, this should be successful.
1114    BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
1115    BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
1116    BOOST_CHECK_EQUAL(ch, ResSuccess);
1117
1118    // When we try to probe the lock now, it should fail.
1119    BOOST_CHECK_EQUAL(util::LockDirectory(dirname, lockname, true), util::LockResult::ErrorLock);
1120
1121    // Unlock the lock in the child process
1122    BOOST_CHECK_EQUAL(write(fd[1], &UnlockCommand, 1), 1);
1123    BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
1124    BOOST_CHECK_EQUAL(ch, ResUnlockSuccess);
1125
1126    // When we try to probe the lock now, it should succeed.
1127    BOOST_CHECK_EQUAL(util::LockDirectory(dirname, lockname, true), util::LockResult::Success);
1128
1129    // Re-lock the lock in the child process, then wait for it to exit, check
1130    // successful return. After that, we check that exiting the process
1131    // has released the lock as we would expect by probing it.
1132    int processstatus;
1133    BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
1134    // The following line invokes the ~CNetCleanup dtor without
1135    // a paired SetupNetworking call. This is acceptable as long as
1136    // ~CNetCleanup is a no-op for non-Windows platforms.
1137    BOOST_CHECK_EQUAL(write(fd[1], &ExitCommand, 1), 1);
1138    BOOST_CHECK_EQUAL(waitpid(pid, &processstatus, 0), pid);
1139    BOOST_CHECK_EQUAL(processstatus, 0);
1140    BOOST_CHECK_EQUAL(util::LockDirectory(dirname, lockname, true), util::LockResult::Success);
1141
1142    BOOST_CHECK_EQUAL(close(fd[1]), 0); // Close our side of the socketpair
1143#endif
1144    // Clean up
1145    ReleaseDirectoryLocks();
1146    fs::remove(dirname / lockname);
1147    fs::remove(dirname);
1148}
1149
1150BOOST_AUTO_TEST_CASE(test_ToLower)
1151{
1152    BOOST_CHECK_EQUAL(ToLower('@'), '@');
1153    BOOST_CHECK_EQUAL(ToLower('A'), 'a');
1154    BOOST_CHECK_EQUAL(ToLower('Z'), 'z');
1155    BOOST_CHECK_EQUAL(ToLower('['), '[');
1156    BOOST_CHECK_EQUAL(ToLower(0), 0);
1157    BOOST_CHECK_EQUAL(ToLower('\xff'), '\xff');
1158
1159    BOOST_CHECK_EQUAL(ToLower(""), "");
1160    BOOST_CHECK_EQUAL(ToLower("#HODL"), "#hodl");
1161    BOOST_CHECK_EQUAL(ToLower("\x00\xfe\xff"), "\x00\xfe\xff");
1162}
1163
1164BOOST_AUTO_TEST_CASE(test_ToUpper)
1165{
1166    BOOST_CHECK_EQUAL(ToUpper('`'), '`');
1167    BOOST_CHECK_EQUAL(ToUpper('a'), 'A');
1168    BOOST_CHECK_EQUAL(ToUpper('z'), 'Z');
1169    BOOST_CHECK_EQUAL(ToUpper('{'), '{');
1170    BOOST_CHECK_EQUAL(ToUpper(0), 0);
1171    BOOST_CHECK_EQUAL(ToUpper('\xff'), '\xff');
1172
1173    BOOST_CHECK_EQUAL(ToUpper(""), "");
1174    BOOST_CHECK_EQUAL(ToUpper("#hodl"), "#HODL");
1175    BOOST_CHECK_EQUAL(ToUpper("\x00\xfe\xff"), "\x00\xfe\xff");
1176}
1177
1178BOOST_AUTO_TEST_CASE(test_Capitalize)
1179{
1180    BOOST_CHECK_EQUAL(Capitalize(""), "");
1181    BOOST_CHECK_EQUAL(Capitalize("bitcoin"), "Bitcoin");
1182    BOOST_CHECK_EQUAL(Capitalize("\x00\xfe\xff"), "\x00\xfe\xff");
1183}
1184
1185static std::string SpanToStr(const std::span<const char>& span)
1186{
1187    return std::string(span.begin(), span.end());
1188}
1189
1190BOOST_AUTO_TEST_CASE(test_script_parsing)
1191{
1192    using namespace script;
1193    std::string input;
1194    std::span<const char> sp;
1195    bool success;
1196
1197    // Const(...): parse a constant, update span to skip it if successful
1198    input = "MilkToastHoney";
1199    sp = input;
1200    success = Const("", sp); // empty
1201    BOOST_CHECK(success);
1202    BOOST_CHECK_EQUAL(SpanToStr(sp), "MilkToastHoney");
1203
1204    success = Const("Milk", sp, /*skip=*/false);
1205    BOOST_CHECK(success);
1206    BOOST_CHECK_EQUAL(SpanToStr(sp), "MilkToastHoney");
1207
1208    success = Const("Milk", sp);
1209    BOOST_CHECK(success);
1210    BOOST_CHECK_EQUAL(SpanToStr(sp), "ToastHoney");
1211
1212    success = Const("Bread", sp, /*skip=*/false);
1213    BOOST_CHECK(!success);
1214
1215    success = Const("Bread", sp);
1216    BOOST_CHECK(!success);
1217
1218    success = Const("Toast", sp, /*skip=*/false);
1219    BOOST_CHECK(success);
1220    BOOST_CHECK_EQUAL(SpanToStr(sp), "ToastHoney");
1221
1222    success = Const("Toast", sp);
1223    BOOST_CHECK(success);
1224    BOOST_CHECK_EQUAL(SpanToStr(sp), "Honey");
1225
1226    success = Const("Honeybadger", sp);
1227    BOOST_CHECK(!success);
1228
1229    success = Const("Honey", sp, /*skip=*/false);
1230    BOOST_CHECK(success);
1231    BOOST_CHECK_EQUAL(SpanToStr(sp), "Honey");
1232
1233    success = Const("Honey", sp);
1234    BOOST_CHECK(success);
1235    BOOST_CHECK_EQUAL(SpanToStr(sp), "");
1236    // Func(...): parse a function call, update span to argument if successful
1237    input = "Foo(Bar(xy,z()))";
1238    sp = input;
1239
1240    success = Func("FooBar", sp);
1241    BOOST_CHECK(!success);
1242
1243    success = Func("Foo(", sp);
1244    BOOST_CHECK(!success);
1245
1246    success = Func("Foo", sp);
1247    BOOST_CHECK(success);
1248    BOOST_CHECK_EQUAL(SpanToStr(sp), "Bar(xy,z())");
1249
1250    success = Func("Bar", sp);