#include <cctype>
+Settings::~Settings()
+{
+ std::map<std::string, SettingsEntry>::const_iterator it;
+ for (it = m_settings.begin(); it != m_settings.end(); ++it)
+ delete it->second.group;
+}
+
+
Settings & Settings::operator += (const Settings &other)
{
update(other);
}
-bool Settings::parseConfigLines(std::istream &is,
- const std::string &end)
+std::string Settings::getMultiline(std::istream &is)
+{
+ std::string value;
+ std::string line;
+
+ while (is.good()) {
+ std::getline(is, line);
+ if (line == "\"\"\"")
+ break;
+ value += line;
+ value.push_back('\n');
+ }
+
+ size_t len = value.size();
+ if (len)
+ value.erase(len - 1);
+
+ return value;
+}
+
+
+bool Settings::parseConfigLines(std::istream &is, const std::string &end)
{
JMutexAutoLock lock(m_mutex);
- std::string name, value;
- bool end_found = false;
+ std::string line, name, value;
- while (is.good() && !end_found) {
- if (parseConfigObject(is, name, value, end, end_found)) {
- m_settings[name] = value;
+ while (is.good()) {
+ std::getline(is, line);
+ SettingsParseEvent event = parseConfigObject(line, end, name, value);
+
+ switch (event) {
+ case SPE_NONE:
+ case SPE_INVALID:
+ case SPE_COMMENT:
+ break;
+ case SPE_KVPAIR:
+ m_settings[name] = SettingsEntry(value);
+ break;
+ case SPE_END:
+ return true;
+ case SPE_GROUP: {
+ Settings *branch = new Settings;
+ if (!branch->parseConfigLines(is, "}"))
+ return false;
+
+ m_settings[name] = SettingsEntry(branch);
+ break;
+ }
+ case SPE_MULTILINE:
+ m_settings[name] = SettingsEntry(getMultiline(is));
+ break;
}
}
- if (!end.empty() && !end_found) {
- return false;
- }
- return true;
+
+ return end.empty();
}
if (!is.good())
return false;
- JMutexAutoLock lock(m_mutex);
+ return parseConfigLines(is, "");
+}
- std::string name, value;
- while (is.good()) {
- if (parseConfigObject(is, name, value)) {
- m_settings[name] = value;
- }
- }
+void Settings::writeLines(std::ostream &os, u32 tab_depth) const
+{
+ JMutexAutoLock lock(m_mutex);
- return true;
+ for (std::map<std::string, SettingsEntry>::const_iterator
+ it = m_settings.begin();
+ it != m_settings.end(); ++it) {
+ bool is_multiline = it->second.value.find('\n') != std::string::npos;
+ printValue(os, it->first, it->second, is_multiline, tab_depth);
+ }
}
-void Settings::writeLines(std::ostream &os) const
+void Settings::printValue(std::ostream &os, const std::string &name,
+ const SettingsEntry &entry, bool is_value_multiline, u32 tab_depth)
{
- JMutexAutoLock lock(m_mutex);
+ for (u32 i = 0; i != tab_depth; i++)
+ os << "\t";
+ os << name << " = ";
- for (std::map<std::string, std::string>::const_iterator
- i = m_settings.begin();
- i != m_settings.end(); ++i) {
- os << i->first << " = " << i->second << '\n';
+ if (is_value_multiline)
+ os << "\"\"\"\n" << entry.value << "\n\"\"\"\n";
+ else
+ os << entry.value << "\n";
+
+ Settings *group = entry.group;
+ if (group) {
+ for (u32 i = 0; i != tab_depth; i++)
+ os << "\t";
+
+ os << name << " = {\n";
+ group->writeLines(os, tab_depth + 1);
+
+ for (u32 i = 0; i != tab_depth; i++)
+ os << "\t";
+
+ os << "}\n";
}
}
-bool Settings::updateConfigFile(const char *filename)
+bool Settings::updateConfigObject(std::istream &is, std::ostream &os,
+ const std::string &end, u32 tab_depth)
{
- std::list<std::string> objects;
- std::set<std::string> updated;
- bool changed = false;
+ std::map<std::string, SettingsEntry>::const_iterator it;
+ std::set<std::string> settings_in_config;
+ bool was_modified = false;
+ bool end_found = false;
+ std::string line, name, value;
- JMutexAutoLock lock(m_mutex);
+ // Add any settings that exist in the config file with the current value
+ // in the object if existing
+ while (is.good() && !end_found) {
+ std::getline(is, line);
+ SettingsParseEvent event = parseConfigObject(line, end, name, value);
+
+ switch (event) {
+ case SPE_END:
+ end_found = true;
+ break;
+ case SPE_KVPAIR:
+ case SPE_MULTILINE:
+ it = m_settings.find(name);
+ if (it != m_settings.end()) {
+ if (event == SPE_MULTILINE)
+ value = getMultiline(is);
+
+ if (value != it->second.value) {
+ value = it->second.value;
+ was_modified = true;
+ }
+ }
- // Read the file and check for differences
- {
- std::ifstream is(filename);
- while (is.good()) {
- getUpdatedConfigObject(is, objects,
- updated, changed);
- }
- }
+ settings_in_config.insert(name);
+
+ printValue(os, name, SettingsEntry(value),
+ event == SPE_MULTILINE, tab_depth);
+
+ break;
+ case SPE_GROUP: {
+ Settings *group = NULL;
+ it = m_settings.find(name);
+ if (it != m_settings.end())
+ group = it->second.group;
- // If something not yet determined to have been changed, check if
- // any new stuff was added
- if (!changed) {
- for (std::map<std::string, std::string>::const_iterator
- i = m_settings.begin();
- i != m_settings.end(); ++i) {
- if (updated.find(i->first) == updated.end()) {
- changed = true;
- break;
+ settings_in_config.insert(name);
+
+ os << name << " = {\n";
+
+ if (group) {
+ was_modified |= group->updateConfigObject(is, os, "}", tab_depth + 1);
+ } else {
+ Settings dummy_settings;
+ dummy_settings.updateConfigObject(is, os, "}", tab_depth + 1);
}
+
+ for (u32 i = 0; i != tab_depth; i++)
+ os << "\t";
+ os << "}\n";
+ break;
+ }
+ default:
+ os << line << (is.eof() ? "" : "\n");
+ break;
}
}
- // If nothing was actually changed, skip writing the file
- if (!changed) {
- return true;
+ // Add any settings in the object that don't exist in the config file yet
+ for (it = m_settings.begin(); it != m_settings.end(); ++it) {
+ if (settings_in_config.find(it->first) != settings_in_config.end())
+ continue;
+
+ was_modified = true;
+
+ bool is_multiline = it->second.value.find('\n') != std::string::npos;
+ printValue(os, it->first, it->second, is_multiline, tab_depth);
}
- // Write stuff back
- {
- std::ostringstream ss(std::ios_base::binary);
+ return was_modified;
+}
- // Write changes settings
- for (std::list<std::string>::const_iterator
- i = objects.begin();
- i != objects.end(); ++i) {
- ss << (*i);
- }
- // Write new settings
- for (std::map<std::string, std::string>::const_iterator
- i = m_settings.begin();
- i != m_settings.end(); ++i) {
- if (updated.find(i->first) != updated.end())
- continue;
- ss << i->first << " = " << i->second << '\n';
- }
+bool Settings::updateConfigFile(const char *filename)
+{
+ JMutexAutoLock lock(m_mutex);
- if (!fs::safeWriteToFile(filename, ss.str())) {
- errorstream << "Error writing configuration file: \""
- << filename << "\"" << std::endl;
- return false;
- }
+ std::ifstream is(filename);
+ std::ostringstream os(std::ios_base::binary);
+
+ if (!updateConfigObject(is, os, ""))
+ return true;
+
+ if (!fs::safeWriteToFile(filename, os.str())) {
+ errorstream << "Error writing configuration file: \""
+ << filename << "\"" << std::endl;
+ return false;
}
return true;
***********/
-std::string Settings::get(const std::string &name) const
+const SettingsEntry &Settings::getEntry(const std::string &name) const
{
JMutexAutoLock lock(m_mutex);
- std::map<std::string, std::string>::const_iterator n;
+ std::map<std::string, SettingsEntry>::const_iterator n;
if ((n = m_settings.find(name)) == m_settings.end()) {
- if ((n = m_defaults.find(name)) == m_defaults.end()) {
+ if ((n = m_defaults.find(name)) == m_defaults.end())
throw SettingNotFoundException("Setting [" + name + "] not found.");
- }
}
return n->second;
}
+Settings *Settings::getGroup(const std::string &name) const
+{
+ return getEntry(name).group;
+}
+
+
+std::string Settings::get(const std::string &name) const
+{
+ return getEntry(name).value;
+}
+
+
bool Settings::getBool(const std::string &name) const
{
return is_yes(get(name));
u32 Settings::getFlagStr(const std::string &name, const FlagDesc *flagdesc,
- u32 *flagmask) const
+ u32 *flagmask) const
{
std::string val = get(name);
return std::isdigit(val[0])
// N.B. if getStruct() is used to read a non-POD aggregate type,
// the behavior is undefined.
bool Settings::getStruct(const std::string &name, const std::string &format,
- void *out, size_t olen) const
+ void *out, size_t olen) const
{
std::string valstr;
std::vector<std::string> Settings::getNames() const
{
std::vector<std::string> names;
- for (std::map<std::string, std::string>::const_iterator
+ for (std::map<std::string, SettingsEntry>::const_iterator
i = m_settings.begin();
i != m_settings.end(); ++i) {
names.push_back(i->first);
* Getters that don't throw exceptions *
***************************************/
+bool Settings::getEntryNoEx(const std::string &name, SettingsEntry &val) const
+{
+ try {
+ val = getEntry(name);
+ return true;
+ } catch (SettingNotFoundException &e) {
+ return false;
+ }
+}
+
+
+bool Settings::getGroupNoEx(const std::string &name, Settings *&val) const
+{
+ try {
+ val = getGroup(name);
+ return true;
+ } catch (SettingNotFoundException &e) {
+ return false;
+ }
+}
+
bool Settings::getNoEx(const std::string &name, std::string &val) const
{
// N.B. getFlagStrNoEx() does not set val, but merely modifies it. Thus,
// val must be initialized before using getFlagStrNoEx(). The intention of
// this is to simplify modifying a flags field from a default value.
-bool Settings::getFlagStrNoEx(const std::string &name, u32 &val, FlagDesc *flagdesc) const
+bool Settings::getFlagStrNoEx(const std::string &name, u32 &val,
+ FlagDesc *flagdesc) const
{
try {
u32 flags, flagmask;
}
-
/***********
* Setters *
***********/
-void Settings::set(const std::string &name, std::string value)
+void Settings::set(const std::string &name, const std::string &value)
{
JMutexAutoLock lock(m_mutex);
- m_settings[name] = value;
+ m_settings[name].value = value;
}
-void Settings::set(const std::string &name, const char *value)
+void Settings::setGroup(const std::string &name, Settings *group)
{
JMutexAutoLock lock(m_mutex);
- m_settings[name] = value;
+ delete m_settings[name].group;
+ m_settings[name].group = group;
}
-void Settings::setDefault(const std::string &name, std::string value)
+void Settings::setDefault(const std::string &name, const std::string &value)
{
JMutexAutoLock lock(m_mutex);
- m_defaults[name] = value;
+ m_defaults[name].value = value;
+}
+
+
+void Settings::setGroupDefault(const std::string &name, Settings *group)
+{
+ JMutexAutoLock lock(m_mutex);
+
+ delete m_defaults[name].group;
+ m_defaults[name].group = group;
}
}
-bool Settings::setStruct(const std::string &name, const std::string &format, void *value)
+bool Settings::setStruct(const std::string &name, const std::string &format,
+ void *value)
{
std::string structstr;
if (!serializeStructToString(&structstr, format, value))
try {
std::string val = other.get(name);
+
m_settings[name] = val;
} catch (SettingNotFoundException &e) {
}
}
-void Settings::registerChangedCallback(std::string name,
- setting_changed_callback cbf)
+SettingsParseEvent Settings::parseConfigObject(const std::string &line,
+ const std::string &end, std::string &name, std::string &value)
{
- m_callbacks[name].push_back(cbf);
-}
-
-
-inline bool Settings::parseConfigObject(std::istream &is,
- std::string &name, std::string &value)
-{
- bool end_found = false;
- return parseConfigObject(is, name, value, "", end_found);
-}
-
-
-// NOTE: This function might be expanded to allow multi-line settings.
-bool Settings::parseConfigObject(std::istream &is,
- std::string &name, std::string &value,
- const std::string &end, bool &end_found)
-{
- std::string line;
- std::getline(is, line);
std::string trimmed_line = trim(line);
- // Ignore empty lines and comments
- if (trimmed_line.empty() || trimmed_line[0] == '#') {
- value = trimmed_line;
- return false;
- }
- if (trimmed_line == end) {
- end_found = true;
- return false;
- }
-
- Strfnd sf(trimmed_line);
-
- name = trim(sf.next("="));
- if (name.empty()) {
- value = trimmed_line;
- return false;
- }
-
- value = trim(sf.next("\n"));
-
- return true;
-}
-
+ if (trimmed_line.empty())
+ return SPE_NONE;
+ if (trimmed_line[0] == '#')
+ return SPE_COMMENT;
+ if (trimmed_line == end)
+ return SPE_END;
-void Settings::getUpdatedConfigObject(std::istream &is,
- std::list<std::string> &dst,
- std::set<std::string> &updated,
- bool &changed)
-{
- std::string name, value;
-
- if (!parseConfigObject(is, name, value)) {
- dst.push_back(value + (is.eof() ? "" : "\n"));
- return;
- }
+ size_t pos = trimmed_line.find('=');
+ if (pos == std::string::npos)
+ return SPE_INVALID;
- if (m_settings.find(name) != m_settings.end()) {
- std::string new_value = m_settings[name];
+ name = trim(trimmed_line.substr(0, pos));
+ value = trim(trimmed_line.substr(pos + 1));
- if (new_value != value) {
- changed = true;
- }
+ if (value == "{")
+ return SPE_GROUP;
+ if (value == "\"\"\"")
+ return SPE_MULTILINE;
- dst.push_back(name + " = " + new_value + (is.eof() ? "" : "\n"));
- updated.insert(name);
- } else { // File contains a setting which is not in m_settings
- changed = true;
- }
+ return SPE_KVPAIR;
}
m_defaults.clear();
}
+
+void Settings::registerChangedCallback(std::string name,
+ setting_changed_callback cbf)
+{
+ m_callbacks[name].push_back(cbf);
+}
+
+
void Settings::doCallbacks(const std::string name)
{
std::vector<setting_changed_callback> tempvector;
#include <list>
#include <set>
-enum ValueType
-{
+class Settings;
+
+/** function type to register a changed callback */
+typedef void (*setting_changed_callback)(const std::string);
+
+enum ValueType {
VALUETYPE_STRING,
VALUETYPE_FLAG // Doesn't take any arguments
};
-struct ValueSpec
-{
+enum SettingsParseEvent {
+ SPE_NONE,
+ SPE_INVALID,
+ SPE_COMMENT,
+ SPE_KVPAIR,
+ SPE_END,
+ SPE_GROUP,
+ SPE_MULTILINE,
+};
+
+struct ValueSpec {
ValueSpec(ValueType a_type, const char *a_help=NULL)
{
type = a_type;
};
/** function type to register a changed callback */
-typedef void (*setting_changed_callback)(const std::string);
+struct SettingsEntry {
+ SettingsEntry()
+ {
+ group = NULL;
+ }
-class Settings
-{
+ SettingsEntry(const std::string &value_)
+ {
+ value = value_;
+ group = NULL;
+ }
+
+ SettingsEntry(Settings *group_)
+ {
+ group = group_;
+ }
+
+ SettingsEntry(const std::string &value_, Settings *group_)
+ {
+ value = value_;
+ group = group_;
+ }
+
+ std::string value;
+ Settings *group;
+};
+
+
+class Settings {
public:
Settings() {}
+ ~Settings();
Settings & operator += (const Settings &other);
Settings & operator = (const Settings &other);
bool parseCommandLine(int argc, char *argv[],
std::map<std::string, ValueSpec> &allowed_options);
bool parseConfigLines(std::istream &is, const std::string &end = "");
- void writeLines(std::ostream &os) const;
+ void writeLines(std::ostream &os, u32 tab_depth=0) const;
+ SettingsParseEvent parseConfigObject(const std::string &line,
+ const std::string &end, std::string &name, std::string &value);
+ bool updateConfigObject(std::istream &is, std::ostream &os,
+ const std::string &end, u32 tab_depth=0);
+
+ static std::string getMultiline(std::istream &is);
+ static void printValue(std::ostream &os, const std::string &name,
+ const SettingsEntry &entry, bool is_value_multiline, u32 tab_depth=0);
/***********
* Getters *
***********/
+ const SettingsEntry &getEntry(const std::string &name) const;
+ Settings *getGroup(const std::string &name) const;
std::string get(const std::string &name) const;
bool getBool(const std::string &name) const;
u16 getU16(const std::string &name) const;
* Getters that don't throw exceptions *
***************************************/
+ bool getEntryNoEx(const std::string &name, SettingsEntry &val) const;
+ bool getGroupNoEx(const std::string &name, Settings *&val) const;
bool getNoEx(const std::string &name, std::string &val) const;
bool getFlag(const std::string &name) const;
bool getU16NoEx(const std::string &name, u16 &val) const;
* Setters *
***********/
- void set(const std::string &name, std::string value);
- void set(const std::string &name, const char *value);
- void setDefault(const std::string &name, std::string value);
+ // N.B. Groups not allocated with new must be set to NULL in the settings
+ // tree before object destruction.
+ void set(const std::string &name, const std::string &value);
+ void setGroup(const std::string &name, Settings *group);
+ void setDefault(const std::string &name, const std::string &value);
+ void setGroupDefault(const std::string &name, Settings *group);
void setBool(const std::string &name, bool value);
void setS16(const std::string &name, s16 value);
void setS32(const std::string &name, s32 value);
void registerChangedCallback(std::string name, setting_changed_callback cbf);
private:
- /***********************
- * Reading and writing *
- ***********************/
-
- bool parseConfigObject(std::istream &is,
- std::string &name, std::string &value);
- bool parseConfigObject(std::istream &is,
- std::string &name, std::string &value,
- const std::string &end, bool &end_found);
- /*
- * Reads a configuration object from stream (usually a single line)
- * and adds it to dst.
- * Preserves comments and empty lines.
- * Setting names that were added to dst are also added to updated.
- */
- void getUpdatedConfigObject(std::istream &is,
- std::list<std::string> &dst,
- std::set<std::string> &updated,
- bool &changed);
-
void updateNoLock(const Settings &other);
void clearNoLock();
void doCallbacks(std::string name);
- std::map<std::string, std::string> m_settings;
- std::map<std::string, std::string> m_defaults;
+ std::map<std::string, SettingsEntry> m_settings;
+ std::map<std::string, SettingsEntry> m_defaults;
std::map<std::string, std::vector<setting_changed_callback> > m_callbacks;
// All methods that access m_settings/m_defaults directly should lock this.
mutable JMutex m_mutex;
}
};
+#define TEST_CONFIG_TEXT_BEFORE \
+ "leet = 1337\n" \
+ "leetleet = 13371337\n" \
+ "leetleet_neg = -13371337\n" \
+ "floaty_thing = 1.1\n" \
+ "stringy_thing = asd /( ¤%&(/\" BLÖÄRP\n" \
+ "coord = (1, 2, 4.5)\n" \
+ " # this is just a comment\n" \
+ "this is an invalid line\n" \
+ "asdf = {\n" \
+ " a = 5\n" \
+ " b = 2.5\n" \
+ " c = \"\"\"\n" \
+ "testy\n" \
+ " testa \n" \
+ "\"\"\"\n" \
+ "\n" \
+ "}\n" \
+ "blarg = \"\"\" \n" \
+ "some multiline text\n" \
+ " with leading whitespace!\n" \
+ "\"\"\"\n" \
+ "zoop = true"
+
+#define TEST_CONFIG_TEXT_AFTER \
+ "leet = 1337\n" \
+ "leetleet = 13371337\n" \
+ "leetleet_neg = -13371337\n" \
+ "floaty_thing = 1.1\n" \
+ "stringy_thing = asd /( ¤%&(/\" BLÖÄRP\n" \
+ "coord = (1, 2, 4.5)\n" \
+ " # this is just a comment\n" \
+ "this is an invalid line\n" \
+ "asdf = {\n" \
+ " a = 5\n" \
+ " b = 2.5\n" \
+ " c = \"\"\"\n" \
+ "testy\n" \
+ " testa \n" \
+ "\"\"\"\n" \
+ "\n" \
+ "}\n" \
+ "blarg = \"\"\"\n" \
+ "some multiline text\n" \
+ " with leading whitespace!\n" \
+ "\"\"\"\n" \
+ "zoop = true\n" \
+ "coord2 = (1,2,3.3)\n" \
+ "floaty_thing_2 = 1.2\n" \
+ "groupy_thing = \n" \
+ "groupy_thing = {\n" \
+ " animals = \n" \
+ " animals = {\n" \
+ " cat = meow\n" \
+ " dog = woof\n" \
+ " }\n" \
+ " num_apples = 4\n" \
+ " num_oranges = 53\n" \
+ "}\n"
+
+
struct TestSettings: public TestBase
{
void Run()
{
Settings s;
+
// Test reading of settings
- std::istringstream is(
- "leet = 1337\n"
- "leetleet = 13371337\n"
- "leetleet_neg = -13371337\n"
- "floaty_thing = 1.1\n"
- "stringy_thing = asd /( ¤%&(/\" BLÖÄRP\n"
- "coord = (1, 2, 4.5)");
+ std::istringstream is(TEST_CONFIG_TEXT_BEFORE);
s.parseConfigLines(is);
+
UASSERT(s.getS32("leet") == 1337);
UASSERT(s.getS16("leetleet") == 32767);
UASSERT(s.getS16("leetleet_neg") == -32768);
+
// Not sure if 1.1 is an exact value as a float, but doesn't matter
UASSERT(fabs(s.getFloat("floaty_thing") - 1.1) < 0.001);
UASSERT(s.get("stringy_thing") == "asd /( ¤%&(/\" BLÖÄRP");
UASSERT(fabs(s.getV3F("coord").X - 1.0) < 0.001);
UASSERT(fabs(s.getV3F("coord").Y - 2.0) < 0.001);
UASSERT(fabs(s.getV3F("coord").Z - 4.5) < 0.001);
+
// Test the setting of settings too
s.setFloat("floaty_thing_2", 1.2);
s.setV3F("coord2", v3f(1, 2, 3.3));
UASSERT(fabs(s.getV3F("coord2").X - 1.0) < 0.001);
UASSERT(fabs(s.getV3F("coord2").Y - 2.0) < 0.001);
UASSERT(fabs(s.getV3F("coord2").Z - 3.3) < 0.001);
+
+ // Test settings groups
+ Settings *group = s.getGroup("asdf");
+ UASSERT(group != NULL);
+ UASSERT(s.getGroup("zoop") == NULL);
+ UASSERT(group->getS16("a") == 5);
+ UASSERT(fabs(group->getFloat("b") - 2.5) < 0.001);
+
+ Settings *group3 = new Settings;
+ group3->set("cat", "meow");
+ group3->set("dog", "woof");
+
+ Settings *group2 = new Settings;
+ group2->setS16("num_apples", 4);
+ group2->setS16("num_oranges", 53);
+ group2->setGroup("animals", group3);
+ s.setGroup("groupy_thing", group2);
+
+ // Test multiline settings
+ UASSERT(group->get("c") == "testy\n testa ");
+ UASSERT(s.get("blarg") ==
+ "some multiline text\n"
+ " with leading whitespace!");
+
+ // Test writing
+ std::ostringstream os(std::ios_base::binary);
+ is.clear();
+ is.seekg(0);
+
+ UASSERT(s.updateConfigObject(is, os, "", 0) == true);
+ //printf(">>>> expected config:\n%s\n", TEST_CONFIG_TEXT_AFTER);
+ //printf(">>>> actual config:\n%s\n", os.str().c_str());
+ UASSERT(os.str() == TEST_CONFIG_TEXT_AFTER);
}
};
UASSERT(serializeWideString(L"") == mkstr("\0\0"));
UASSERT(serializeLongString("") == mkstr("\0\0\0\0"));
UASSERT(serializeJsonString("") == "\"\"");
-
+
std::string teststring = "Hello world!";
UASSERT(serializeString(teststring) ==
mkstr("\0\14Hello world!"));
fromdata[1]=5;
fromdata[2]=5;
fromdata[3]=1;
-
+
std::ostringstream os(std::ios_base::binary);
compress(fromdata, os, 0);
std::string str_out = os.str();
-
+
infostream<<"str_out.size()="<<str_out.size()<<std::endl;
infostream<<"TestCompress: 1,5,5,1 -> ";
for(u32 i=0; i<str_out.size(); i++)
fromdata[1]=5;
fromdata[2]=5;
fromdata[3]=1;
-
+
std::ostringstream os(std::ios_base::binary);
compress(fromdata, os, SER_FMT_VER_HIGHEST_READ);
std::string str_out = os.str();
-
+
infostream<<"str_out.size()="<<str_out.size()<<std::endl;
infostream<<"TestCompress: 1,5,5,1 -> ";
for(u32 i=0; i<str_out.size(); i++)
UASSERT(n.getContent() == CONTENT_AIR);
UASSERT(n.getLight(LIGHTBANK_DAY, nodedef) == 0);
UASSERT(n.getLight(LIGHTBANK_NIGHT, nodedef) == 0);
-
+
// Transparency
n.setContent(CONTENT_AIR);
UASSERT(nodedef->get(n).light_propagates == true);
VoxelArea a(v3s16(-1,-1,-1), v3s16(1,1,1));
UASSERT(a.index(0,0,0) == 1*3*3 + 1*3 + 1);
UASSERT(a.index(-1,-1,-1) == 0);
-
+
VoxelArea c(v3s16(-2,-2,-2), v3s16(2,2,2));
// An area that is 1 bigger in x+ and z-
VoxelArea d(v3s16(-2,-2,-3), v3s16(3,2,2));
-
+
std::list<VoxelArea> aa;
d.diff(c, aa);
-
+
// Correct results
std::vector<VoxelArea> results;
results.push_back(VoxelArea(v3s16(-2,-2,-3),v3s16(3,2,-3)));
results.push_back(VoxelArea(v3s16(3,-2,-2),v3s16(3,2,2)));
UASSERT(aa.size() == results.size());
-
+
infostream<<"Result of diff:"<<std::endl;
for(std::list<VoxelArea>::const_iterator
i = aa.begin(); i != aa.end(); ++i)
{
i->print(infostream);
infostream<<std::endl;
-
+
std::vector<VoxelArea>::iterator j = std::find(results.begin(), results.end(), *i);
UASSERT(j != results.end());
results.erase(j);
/*
VoxelManipulator
*/
-
+
VoxelManipulator v;
v.print(infostream, nodedef);
infostream<<"*** Setting (-1,0,-1)=2 ***"<<std::endl;
-
+
v.setNodeNoRef(v3s16(-1,0,-1), MapNode(CONTENT_GRASS));
v.print(infostream, nodedef);
infostream<<"*** Adding area ***"<<std::endl;
v.addArea(a);
-
+
v.print(infostream, nodedef);
UASSERT(v.getNode(v3s16(-1,0,-1)).getContent() == CONTENT_GRASS);
"Empty\n"
"EndInventoryList\n"
"EndInventory\n";
-
+
std::string serialized_inventory_2 =
"List main 32\n"
"Width 5\n"
"Empty\n"
"EndInventoryList\n"
"EndInventory\n";
-
+
Inventory inv(idef);
std::istringstream is(serialized_inventory, std::ios::binary);
inv.deSerialize(is);
void Run()
{
TC parent;
-
+
MapBlock b(&parent, v3s16(1,1,1));
v3s16 relpos(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE);
UASSERT(b.getBox().MaxEdge.Y == MAP_BLOCKSIZE*2-1);
UASSERT(b.getBox().MinEdge.Z == MAP_BLOCKSIZE);
UASSERT(b.getBox().MaxEdge.Z == MAP_BLOCKSIZE*2-1);
-
+
UASSERT(b.isValidPosition(v3s16(0,0,0)) == true);
UASSERT(b.isValidPosition(v3s16(-1,0,0)) == false);
UASSERT(b.isValidPosition(v3s16(-1,-142,-2341)) == false);
*/
/*UASSERT(b.getSizeNodes() == v3s16(MAP_BLOCKSIZE,
MAP_BLOCKSIZE, MAP_BLOCKSIZE));*/
-
+
// Changed flag should be initially set
UASSERT(b.getModified() == MOD_STATE_WRITE_NEEDED);
b.resetModified();
UASSERT(b.getNode(v3s16(x,y,z)).getLight(LIGHTBANK_DAY) == 0);
UASSERT(b.getNode(v3s16(x,y,z)).getLight(LIGHTBANK_NIGHT) == 0);
}
-
+
{
MapNode n(CONTENT_AIR);
for(u16 z=0; z<MAP_BLOCKSIZE; z++)
b.setNode(v3s16(x,y,z), n);
}
}
-
+
/*
Parent fetch functions
*/
parent.node.setContent(5);
MapNode n;
-
+
// Positions in the block should still be valid
UASSERT(b.isValidPositionParent(v3s16(0,0,0)) == true);
UASSERT(b.isValidPositionParent(v3s16(MAP_BLOCKSIZE-1,MAP_BLOCKSIZE-1,MAP_BLOCKSIZE-1)) == true);
UASSERT(b.isValidPositionParent(v3s16(-121,2341,0)) == false);
UASSERT(b.isValidPositionParent(v3s16(-1,0,0)) == false);
UASSERT(b.isValidPositionParent(v3s16(MAP_BLOCKSIZE-1,MAP_BLOCKSIZE-1,MAP_BLOCKSIZE)) == false);
-
+
{
bool exception_thrown = false;
try{
//TODO: Update to new system
/*UASSERT(b.getNodeTile(p) == 4);
UASSERT(b.getNodeTile(v3s16(-1,-1,0)) == 5);*/
-
+
/*
propagateSunlight()
*/
if(position_valid == false)
throw InvalidPositionException();
};
-
+
virtual u16 nodeContainerId() const
{
return 666;
}
};
-
+
void Run()
{
TC parent;
parent.position_valid = false;
-
+
// Create one with no heightmaps
ServerMapSector sector(&parent, v2s16(1,1));
-
+
UASSERT(sector.getBlockNoCreateNoEx(0) == 0);
UASSERT(sector.getBlockNoCreateNoEx(1) == 0);
MapBlock * bref = sector.createBlankBlock(-2);
-
+
UASSERT(sector.getBlockNoCreateNoEx(0) == 0);
UASSERT(sector.getBlockNoCreateNoEx(-2) == bref);
-
+
//TODO: Check for AlreadyExistsException
/*bool exception_thrown = false;
UASSERT(readU16(&p1.data[4]) == peer_id);
UASSERT(readU8(&p1.data[6]) == channel);
UASSERT(readU8(&p1.data[7]) == data1[0]);
-
+
//infostream<<"initial data1[0]="<<((u32)data1[0]&0xff)<<std::endl;
SharedBuffer<u8> p2 = con::makeReliablePacket(data1, seqnum);
Handler hand_server("server");
Handler hand_client("client");
-
+
infostream<<"** Creating server Connection"<<std::endl;
con::Connection server(proto_id, 512, 5.0, false, &hand_server);
Address address(0,0,0,0, 30001);
server.Serve(address);
-
+
infostream<<"** Creating client Connection"<<std::endl;
con::Connection client(proto_id, 512, 5.0, false, &hand_client);
-
+
UASSERT(hand_server.count == 0);
UASSERT(hand_client.count == 0);
-
+
sleep_ms(50);
-
+
Address server_address(127,0,0,1, 30001);
infostream<<"** running client.Connect()"<<std::endl;
client.Connect(server_address);
sleep_ms(50);
-
+
// Client should not have added client yet
UASSERT(hand_client.count == 0);
-
+
try
{
u16 peer_id;
UASSERT(hand_client.last_id == 1);
// Server should not have added client yet
UASSERT(hand_server.count == 0);
-
+
sleep_ms(100);
try
// No actual data received, but the client has
// probably been connected
}
-
+
// Client should be the same
UASSERT(hand_client.count == 1);
UASSERT(hand_client.last_id == 1);
// Server should have the client
UASSERT(hand_server.count == 1);
UASSERT(hand_server.last_id == 2);
-
+
//sleep_ms(50);
while(client.Connected() == false)
}
sleep_ms(50);
-
+
try
{
u16 peer_id;
Address client_address =
server.GetPeerAddress(peer_id_client);
-
+
infostream<<"*** Sending packets in wrong order (2,1,2)"
<<std::endl;
-
+
u8 chn = 0;
con::Channel *ch = &server.getPeer(peer_id_client)->channels[chn];
u16 sn = ch->next_outgoing_seqnum;
UASSERT(size == data1.getSize());
UASSERT(memcmp(*data1, *recvdata, data1.getSize()) == 0);
UASSERT(peer_id == PEER_ID_SERVER);
-
+
infostream<<"** running client.Receive()"<<std::endl;
peer_id = 132;
size = client.Receive(peer_id, recvdata);
UASSERT(size == data2.getSize());
UASSERT(memcmp(*data2, *recvdata, data2.getSize()) == 0);
UASSERT(peer_id == PEER_ID_SERVER);
-
+
bool got_exception = false;
try
{
SharedBuffer<u8> data1(datasize);
for(u16 i=0; i<datasize; i++)
data1[i] = i/4;
-
+
int sendtimes = myrand_range(1,10);
for(int i=0; i<sendtimes; i++){
server.Send(peer_id_client, 0, data1, true);
sendcount++;
}
infostream<<"sendcount="<<sendcount<<std::endl;
-
+
//int receivetimes = myrand_range(1,20);
int receivetimes = 20;
for(int i=0; i<receivetimes; i++){
if(datasize>20)
infostream<<"...";
infostream<<std::endl;
-
+
server.Send(peer_id_client, 0, data1, true);
//sleep_ms(3000);
-
+
SharedBuffer<u8> recvdata;
infostream<<"** running client.Receive()"<<std::endl;
u16 peer_id = 132;
UASSERT(memcmp(*data1, *recvdata, data1.getSize()) == 0);
UASSERT(peer_id == PEER_ID_SERVER);
}
-
+
// Check peer handlers
UASSERT(hand_client.count == 1);
UASSERT(hand_client.last_id == 1);
UASSERT(hand_server.count == 1);
UASSERT(hand_server.last_id == 2);
-
+
//assert(0);
}
};
int tests_run = 0;
int tests_failed = 0;
-
+
// Create item and node definitions
IWritableItemDefManager *idef = createItemDefManager();
IWritableNodeDefManager *ndef = createNodeDefManager();
projects / oweals / minetest.git / commitdiff