#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "config.h"
#ifdef HAVE_LIBOTR
#include <libotr/proto.h>
#include "otr/otr.h"
#endif
#include "config/preferences.h"
#include "command/cmd_defs.h"
#include "command/cmd_funcs.h"
#include "ui/window_list.h"
#include "xmpp/xmpp.h"
#include "ui/ui.h"
#include "ui/stub_ui.h"
#define CMD_OTR "/otr"
#ifdef HAVE_LIBOTR
void
cmd_otr_log_shows_usage_when_no_args(void** state)
{
gchar* args[] = { "log", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_OTR);
gboolean result = cmd_otr_log(NULL, CMD_OTR, args);
assert_true(result);
}
void
cmd_otr_log_shows_usage_when_invalid_subcommand(void** state)
{
gchar* args[] = { "log", "wrong", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_OTR);
gboolean result = cmd_otr_log(NULL, CMD_OTR, args);
assert_true(result);
}
void
cmd_otr_log_on_enables_logging(void** state)
{
gchar* args[] = { "log", "on", NULL };
prefs_set_string(PREF_OTR_LOG, "off");
prefs_set_boolean(PREF_CHLOG, TRUE);
expect_cons_show("OTR messages will be logged as plaintext.");
gboolean result = cmd_otr_log(NULL, CMD_OTR, args);
char* pref_otr_log = prefs_get_string(PREF_OTR_LOG);
assert_true(result);
assert_string_equal("on", pref_otr_log);
g_free(pref_otr_log);
}
void
cmd_otr_log_on_shows_warning_when_chlog_disabled(void** state)
{
gchar* args[] = { "log", "on", NULL };
prefs_set_string(PREF_OTR_LOG, "off");
prefs_set_boolean(PREF_CHLOG, FALSE);
expect_cons_show("OTR messages will be logged as plaintext.");
expect_cons_show("Chat logging is currently disabled, use '/logging chat on' to enable.");
gboolean result = cmd_otr_log(NULL, CMD_OTR, args);
assert_true(result);
}
void
cmd_otr_log_off_disables_logging(void** state)
{
gchar* args[] = { "log", "off", NULL };
prefs_set_string(PREF_OTR_LOG, "on");
prefs_set_boolean(PREF_CHLOG, TRUE);
expect_cons_show("OTR message logging disabled.");
gboolean result = cmd_otr_log(NULL, CMD_OTR, args);
char* pref_otr_log = prefs_get_string(PREF_OTR_LOG);
assert_true(result);
assert_string_equal("off", pref_otr_log);
g_free(pref_otr_log);
}
void
cmd_otr_redact_redacts_logging(void** state)
{
gchar* args[] = { "log", "redact", NULL };
prefs_set_string(PREF_OTR_LOG, "on");
prefs_set_boolean(PREF_CHLOG, TRUE);
expect_cons_show("OTR messages will be logged as '[redacted]'.");
gboolean result = cmd_otr_log(NULL, CMD_OTR, args);
char* pref_otr_log = prefs_get_string(PREF_OTR_LOG);
assert_true(result);
assert_string_equal("redact", pref_otr_log);
g_free(pref_otr_log);
}
void
cmd_otr_log_redact_shows_warning_when_chlog_disabled(void** state)
{
gchar* args[] = { "log", "redact", NULL };
prefs_set_string(PREF_OTR_LOG, "off");
prefs_set_boolean(PREF_CHLOG, FALSE);
expect_cons_show("OTR messages will be logged as '[redacted]'.");
expect_cons_show("Chat logging is currently disabled, use '/logging chat on' to enable.");
gboolean result = cmd_otr_log(NULL, CMD_OTR, args);
assert_true(result);
}
void
cmd_otr_libver_shows_libotr_version(void** state)
{
gchar* args[] = { "libver", NULL };
char* version = "9.9.9";
GString* message = g_string_new("Using libotr version ");
g_string_append(message, version);
will_return(otr_libotr_version, version);
expect_cons_show(message->str);
gboolean result = cmd_otr_libver(NULL, CMD_OTR, args);
assert_true(result);
g_string_free(message, TRUE);
}
void
cmd_otr_gen_shows_message_when_not_connected(void** state)
{
gchar* args[] = { "gen", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
expect_cons_show("You must be connected with an account to load OTR information.");
gboolean result = cmd_otr_gen(NULL, CMD_OTR, args);
assert_true(result);
}
static void
test_with_command_and_connection_status(char* command, void* cmd_func, jabber_conn_status_t status)
{
gchar* args[] = { command, NULL };
will_return(connection_get_status, status);
expect_cons_show("You must be connected with an account to load OTR information.");
gboolean (*func)(ProfWin * window, const char* const comma//: An alternative syntax for reagents that permits whitespace in properties,
//: grouped by brackets. We'll use this ability in the next layer, when we
//: generalize types from lists to trees of properties.
:(scenarios load)
:(scenario dilated_reagent)
def main [
{1: number, foo: bar} <- copy 34
]
+parse: product: {1: "number", "foo": "bar"}
:(scenario load_trailing_space_after_curly_bracket)
def main [
# line below has a space at the end
{
]
# successfully parsed
:(scenario dilated_reagent_with_comment)
def main [
{1: number, foo: bar} <- copy 34 # test comment
]
+parse: product: {1: "number", "foo": "bar"}
$error: 0
:(scenario dilated_reagent_with_comment_immediately_following)
def main [
1:number <- copy {34: literal} # test comment
]
$error: 0
//: First augment next_word to group balanced brackets together.
:(before "End next_word Special-cases")
if (in.peek() == '(')
return slurp_balanced_bracket(in);
// treat curlies mostly like parens, but don't mess up labels
if (start_of_dilated_reagent(in))
return slurp_balanced_bracket(in);
:(code)
// A curly is considered a label if it's the last thing on a line. Dilated
// reagents should remain all on one line.
bool start_of_dilated_reagent(istream& in) {
if (in.peek() != '{') return false;
int pos = in.tellg();
in.get(); // slurp '{'
skip_whitespace_but_not_newline(in);
char next = in.peek();
in.seekg(pos);
return next != '\n';
}
// Assume the first letter is an open bracket, and read everything until the
// matching close bracket.
// We balance {} () and [].
string slurp_balanced_bracket(istream& in) {
ostringstream result;
char c;
list<char> open_brackets;
while (in >> c) {
if (c == '(') open_brackets.push_back(c);
if (c == ')') {
if (open_brackets.empty() || open_brackets.back() != '(') {
raise << "unbalanced ')'\n" << end();
continue;
}
assert(open_brackets.back() == '(');
open_brackets.pop_back();
}
if (c == '[') open_brackets.push_back(c);
if (c == ']') {
if (open_brackets.empty() || open_brackets.back() != '[') {
raise << "unbalanced ']'\n" << end();
continue;
}
open_brackets.pop_back();
}
if (c == '{') open_brackets.push_back(c);
if (c == '}') {
if (open_brackets.empty() || open_brackets.back() != '{') {
raise << "unbalanced '}'\n" << end();
continue;
}
open_brackets.pop_back();
}
result << c;
if (open_brackets.empty()) break;
}
skip_whitespace_and_comments_but_not_newline(in);
return result.str();
}
:(after "Parsing reagent(string s)")
if (starts_with(s, "{")) {
assert(properties.empty());
istringstream in(s);
in >> std::noskipws;
in.get(); // skip '{'
name = slurp_key(in);
if (name.empty()) {
raise << "invalid reagent '" << s << "' without a name\n" << end();
return;
}
if (name == "}") {
raise << "invalid empty reagent '" << s << "'\n" << end();
return;
}
{
string s = next_word(in);
if (s.empty()) {
assert(!has_data(in));
raise << "incomplete dilated reagent at end of file (0)\n" << end();
return;
}
string_tree* type_names = new string_tree(s);
// End Parsing Dilated Reagent Type Property(type_names)
type = new_type_tree(type_names);
delete type_names;
}
while (has_data(in)) {
string key = slurp_key(in);
if (key.empty()) continue;
if (key == "}") continue;
string s = next_word(in);
if (s.empty()) {
assert(!has_data(in));
raise << "incomplete dilated reagent at end of file (1)\n" << end();
return;
}
string_tree* value = new string_tree(s);
// End Parsing Dilated Reagent Property(value)
properties.push_back(pair<string, string_tree*>(key, value));
}
return;
}
:(code)
string slurp_key(istream& in) {
string result = next_word(in);
if (result.empty()) {
assert(!has_data(in));
raise << "incomplete dilated reagent at end of file (2)\n" << end();
return result;
}
while (!result.empty() && *result.rbegin() == ':')
strip_last(result);
while (isspace(in.peek()) || in.peek() == ':')
in.get();
return result;
}