module&	module::set_input_rollback(Record_info &op_info) {
	net* tar_net = op_info.net_ref;
	bool value = !op_info.value_set;

	if (!_set_input(tar_net, value))
		throw exception("rollback set input failed. (set_input_rollback)");
	return *this;
}
Exemple #2
0
/*
 * Set input string
 * @param input input string
 * @param is_file true if file, false otherwise
 * @return true on success, false otherwise
 */
bool 
_par::set_input(
	const std::string &input,
	bool is_file
	)
{
	return _set_input(
		input,
		is_file
		);
}
Exemple #3
0
static void
test1() {
  
  struct KeyVal *kv;
  _check_err(KeyVal_new(&kv), "KeyVal_new");

  // 1a: missing file
  remove(IN);
  _check_load_return(kv, 2, "1a. detects missing input file");

  // 1b: file with complete crap in it
  _set_input("this file has complete crap in it\n");
  _check_load_return(kv, 1, "1b. detects complete crap");

  // 1c: file with EOF in key
  _set_input("`key");
  _check_load_return(kv, 1, "1c. detects EOF in key");

  // 1d/1e: file with missing "=" or "remove"
  _set_input("`key`\n");
  _check_load_return(kv, 1, "1d. detects '\\n' instead of '=' or 'remove'");
  _set_input("`key`");
  _check_load_return(kv, 1, "1e. detects EOF instead of '=' or 'remove'");

  // 1f: file with "foo" instead of "=" or "remove"
  _set_input("`key` foo");
  _check_load_return(kv, 1, "1f. detects crap instead of '=' or 'remove'");

  // 1g/1h: file with missing value
  _set_input("`key` =\n");
  _check_load_return(kv, 1, "1g. detects '\\n' instead of value");
  _set_input("`key` =");
  _check_load_return(kv, 1, "1h. detects EOF instead of value");

  // 1i: file with EOF in value
  _set_input("`key` = `val");
  _check_load_return(kv, 1, "1i. detects EOF in value (missing close-quote)");

  // 1j: file with comment after value (sorry, not allowed!)
  _set_input("`key` = `val` #moo!");
  _check_load_return(kv, 1, "1j. detects comment after value");

  _check_err(KeyVal_delete(kv), "KeyVal_delete");
}
module& module::set_input(net* tar_net, bool value) {
	if (tar_net == NULL)
		throw exception("NULL net specified. (set_input)");
	if (!_set_input(tar_net, value))
		throw exception(("setting " + tar_net->get_net_name() + ((value)? "" : " not") + 
			" as input failed. (set_input)").c_str());
	
	Record new_record;
	new_record.op_type = SI;
	new_record.op_info.net_ref = tar_net;
	new_record.op_info.value_set = value;
	lRecordLst.push_back(new_record);
	return *this;
}
Exemple #5
0
static void
test2() {
  struct KeyVal *kv;
  _check_err(KeyVal_new(&kv), "KeyVal_new");

  // 2a: file with nothing in it
  FILE *fh = fopen(IN, "w");
  fclose(fh);
  _check_load_return(kv, 0, "2a. empty input file");

  // 2b: file with only whitespace
  _set_input("  \t \t  \n\t\t  \n\n ");  // also tests missing \n at EOF
  _check_load_return(kv, 0, "2b. whitespace-only input file");

  // 2c: file with only comments
  _set_input("# nothing\n# at all!\n");
  _check_load_return(kv, 0, "2c. comment-only input file");

  // 2d: save it out; should get nothing
  _check_err(KeyVal_save(kv, OUT, 0, 0), "KeyVal_save");
  ok(_check_output("") == 0, "2d. writing out empty input generates empty output");

  _check_err(KeyVal_delete(kv), "KeyVal_delete");
}
Exemple #6
0
static void
test5() {

  struct KeyVal *kv;
  _check_err(KeyVal_new(&kv), "KeyVal_new");

  // 5a: key and val with escaped quote.  Input should look like this:
  // `\`key\\` = `\\val\``
  // `key\`\`key` = `val\\\\val`
  const char *TEXT = "`\\`key\\\\` = `\\\\val\\``\n`key\\`\\`key` = `val\\\\\\\\val`\n";
  _set_input(TEXT);
  if (!ok(KeyVal_load(kv, IN) == 0, "5a. reads escapes ok")) return;

  // 5b. escapes on the outside of key:
  char *value;
  _check_err(KeyVal_getValue(&value, kv, "`key\\", 0), "KeyVal_getValue");
  if (ok(value != 0, "5b. key with escapes at start and end")) {

    // 5c. escapes on the outsides of value:
    ok(strcmp(value, "\\val`") == 0, "5c. value with escapes at start and end");
  }

  // 5d. (consecutive) escapes in the middle of key:
  _check_err(KeyVal_getValue(&value, kv, "key``key", 0), "KeyVal_getValue");
  if (ok(value != 0, "5d. key with consecutive escapes in middle")) {

    // 5e. (consecutive) escapes in the middle of value:
    ok(strcmp(value, "val\\\\val") == 0, "5e. value with consecutive escapes in middle");
  }

  // 5f. write out this nastiness:
  _check_err(KeyVal_save(kv, OUT, 0, 0), "KeyVal_save");
  ok(_check_output(TEXT) == 0, "5f. escapes write out correctly");

  _check_err(KeyVal_delete(kv), "KeyVal_delete");
}
Exemple #7
0
static void
test3() {
  struct KeyVal *kv;
  _check_err(KeyVal_new(&kv), "KeyVal_new");

  // 3a: unloaded kv should be empty:
  unsigned long size;
  _check_err(KeyVal_size(&size, kv), "KeyVal_size");
  ok(size == 0, "3a. uninitialized KeyVal empty");
  // 3b: single-element file
  _set_input("`key` = `val`\n");  // minimal typical input
  if (!ok(KeyVal_load(kv, IN) == 0, "3b. reads single-element input")) return;
  // 3c: size set from file input
  _check_err(KeyVal_size(&size, kv), "KeyVal_size");
  ok(size == 1, "3c. size of single-element input is 1");

  // 3d: search for element before it:
  char *value;
  _check_err(KeyVal_getValue(&value, kv, "asdf", 0), "KeyVal_getValue");
  if (!ok(value == 0, "3d. search for nonexistent 'asdf'")) {
    printf(" - instead found '%s'!\n", value);
  }
  // 3e: search for element after it:
  _check_err(KeyVal_getValue(&value, kv, "zxcv", 0), "KeyVal_getValue");
  ok(value == 0, "3e. search for nonexistent 'zxcv'");

  // 3f: search for it itself:
  _check_err(KeyVal_getValue(&value, kv, "key", 0), "KeyVal_getValue");
  if (ok(value != 0, "3f. search for existing 'key'")) {
    // 3g: has the right value:
    ok(strcmp(value, "val") == 0, "3g. 'key' has value 'val'");
  }

  // 3h: search for subset key:
  _check_err(KeyVal_getValue(&value, kv, "ke", 0), "KeyVal_getValue");
  if (!ok(value == 0, "3h. search for subset 'ke'")) {
    printf(" - instead found '%s'!\n", value);
  }
  // 3i: search for superset key:
  _check_err(KeyVal_getValue(&value, kv, "keysha", 0), "KeyVal_getValue");
  ok(value == 0, "3i. search for superset 'keysha'");


  // 3j: getKeys returns one thing
  char ** keys;
  _check_err(KeyVal_getKeys(&keys, kv, ""), "KeyVal_getKeys");
  if (keys) {
    if (!ok(keys[0]!=0 && !strcmp(keys[0], "key") && keys[1]==0, "3j. getKeys returns ['key']")) {
      printf("keys returned:\n");
      for (char **f = keys;
          *f;
          ++f) {
        printf("  '%s'\n", *f);
      }
    }
    for (char **f = keys;
        *f;
        ++f) {
      free(*f);
    }
    free(keys);
  }
  else {
    printf("[UNEXPECTED-1] getKeys should never return a null result");
  }

  // 3k: hasValue should find it:
  unsigned char boolflag;
  _check_err(KeyVal_hasValue(&boolflag, kv, "key"), "KeyVal_hasValue");
  ok(boolflag == 1, "3k. hasValue finds 'key'");

  // 3l: hasKeys should not segfault on it:
  _check_err(KeyVal_hasKeys(&boolflag, kv, "key"), "KeyVal_hasKeys");
  ok(boolflag == 0, "3l. hasKeys does not segfault on last element, and doesn't report 'key'");

  // 3m: exists should also find it:
  _check_err(KeyVal_exists(&boolflag, kv, "key"), "KeyVal_exists");
  ok(boolflag == 1, "3m. exists finds 'key'");

  // 3n: save it out; should get single value
  _check_err(KeyVal_save(kv, OUT, 0, 0), "KeyVal_save");
  ok(_check_output("`key` = `val`\n") == 0, "3n. writes out the single value");


  // 3o: removing element before:
  _check_err(KeyVal_remove(kv, "asdf"), "KeyVal_remove");
  _check_err(KeyVal_size(&size, kv), "KeyVal_size");
  ok(size == 1, "3o. removing nonexistent 'asdf'");
  // 3p: removing element after:
  _check_err(KeyVal_remove(kv, "zxcv"), "KeyVal_remove");
  _check_err(KeyVal_size(&size, kv), "KeyVal_size");
  ok(size == 1, "3p. removing nonexistent 'zxcv'");
  // 3q: removing element:
  _check_err(KeyVal_remove(kv, "key"), "KeyVal_remove");
  _check_err(KeyVal_size(&size, kv), "KeyVal_size");
  ok(size == 0, "3q. removing 'key'");

  // 3r: getKeys returns nothing
  _check_err(KeyVal_getKeys(&keys, kv, ""), "KeyVal_getKeys");
  if (keys) {
    ok(keys[0] == 0, "3r: getKeys now returns ['']");
    free(keys);
  }
  else {
    printf("[UNEXPECTED-2] getKeys should never return a null result");
  }

  // 3s: save it out; should get nothing now
  _check_err(KeyVal_save(kv, OUT, 0, 0), "KeyVal_save");
  ok(_check_output("") == 0, "3s. writes out empty file");

  _check_err(KeyVal_delete(kv), "KeyVal_delete");
}
Exemple #8
0
// Set pin as input
static inline void Pin_Input(struct _pin_t pin) {
    _set_input(pin.port, pin.mask);
}