bool test_file_directory_find (Test *test)
{
char *path;
Directory *directory;
Directory *found_directory;
File *found_file;
TITLE ();
CATCH (!(path = directory_current_path ()));
CATCH (!string_append (&path, "/stage/find"));
/*
d stage/find
f f1
d stage/find/d1
*/
CATCH (!(directory = directory_open (path)));
string_destroy (path);
CATCH (!directory_read (directory));
CATCH (!directory->directories);
CATCH (!directory->files);
CATCH (directory->directories->count != 1);
CATCH (directory->files->count != 1);
CATCH (!(found_directory = directory_find_directory (directory, "d1")));
CATCH (!string_equals (found_directory->name, "d1"));
CATCH (directory_find_directory (directory, "d2"));
CATCH (!(found_file = directory_find_file (directory, "f1")));
CATCH (!string_equals (found_file->name, "f1"));
CATCH (directory_find_file (directory, "f2"));
directory_close (directory);
PASS ();
}
void join_path(Value* left, Value* right)
{
const char* leftStr = as_cstring(left);
const char* rightStr = as_cstring(right);
int left_len = (int) strlen(leftStr);
int right_len = (int) strlen(leftStr);
if (string_equals(left, "") || string_equals(left, ".")) {
copy(right, left);
return;
}
if (string_equals(right, ""))
return;
int seperatorCount = 0;
if (left_len > 0 && is_path_seperator(leftStr[left_len-1]))
seperatorCount++;
if (right_len > 0 && is_path_seperator(rightStr[0]))
seperatorCount++;
if (seperatorCount == 2)
string_resize(left, left_len - 1);
else if (seperatorCount == 0)
string_append(left, "/");
string_append(left, right);
}
int main(int argc, char **argv) {
char *arg;
char *address = NULL;
char *language = NULL;
bool use_json = false;
string_array *languages = NULL;
for (int i = 1; i < argc; i++) {
arg = argv[i];
if (string_equals(arg, "-h") || string_equals(arg, "--help")) {
printf(LIBPOSTAL_USAGE);
exit(EXIT_SUCCESS);
} else if (string_equals(arg, "--json")) {
use_json = true;
} else if (address == NULL) {
address = arg;
} else if (!string_starts_with(arg, "-")) {
if (languages == NULL) {
languages = string_array_new();
}
string_array_push(languages, arg);
}
}
if (address == NULL && (!use_json || isatty(fileno(stdin)))) {
log_error(LIBPOSTAL_USAGE);
exit(EXIT_FAILURE);
}
if (!libpostal_setup() || (languages == NULL && !libpostal_setup_language_classifier())) {
exit(EXIT_FAILURE);
}
normalize_options_t options = get_libpostal_default_options();
if (languages != NULL) {
options.languages = languages->a;
options.num_languages = languages->n;
}
if (address == NULL) {
char *line;
while ((line = file_getline(stdin)) != NULL) {
print_output(line, options, use_json);
free(line);
}
} else {
print_output(address, options, use_json);
}
if (languages != NULL) {
string_array_destroy(languages);
}
libpostal_teardown();
libpostal_teardown_language_classifier();
}
void get_path_relative_to_source(caBlock* relativeTo, Value* relPath, Value* result)
{
if (relativeTo == NULL) {
copy(relPath, result);
return;
}
// Don't modify absolute paths
if (is_absolute_path(relPath)) {
copy(relPath, result);
return;
}
Value scriptLocation;
get_source_file_location(relativeTo, &scriptLocation);
if (string_equals(&scriptLocation, "") || string_equals(&scriptLocation, ".")) {
set_value(result, relPath);
return;
}
set_value(result, &scriptLocation);
if (!string_equals(relPath,"")) {
string_append(result, "/");
string_append(result, relPath);
}
}
void test_equality_with_symbol()
{
Value val;
set_symbol(&val, s_Append);
test_assert(string_equals(&val, ":Append"));
test_assert(!string_equals(&val, "Append"));
test_assert(!string_equals(&val, "Appen"));
}
void leerArchivoDeConfiguracion(int argc, char *argv[]) {
char* logMsg = NULL;
if (argc < 2) {
logMsg =
string_from_format(
"Debe especificar la ruta al archivo de configuracion, al invocar al programa, por ejemplo: ./Memoria /home/utnso/tp-2015-2c-tpso/Memoria/config_memoria.cfg\n");
puts(logMsg);
my_log_error(logMsg);
exit(-1);
}
char* nombreArchivoConfig = nombreArchivoConfig = strdup(argv[1]);
uint8_t result = checkearRutaArchivoConfig(nombreArchivoConfig);
if (result == -1) {
logMsg = string_from_format("Archivo de configuracion no encontrado. Parametro especificado: %s\n", nombreArchivoConfig);
puts(logMsg);
my_log_error(logMsg);
exit(-1);
} else {
t_config* archivoConfig;
archivoConfig = config_create(nombreArchivoConfig);
//warning asignacion diferentes tipos
configuracion = iniciarArchivoConfig();
configuracion->puertoEscucha = config_get_int_value(archivoConfig, "PUERTO_ESCUCHA");
configuracion->puertoSwap = config_get_int_value(archivoConfig, "PUERTO_SWAP");
configuracion->ipSwap = strdup(config_get_string_value(archivoConfig, "IP_SWAP"));
char* nombreMemoria = config_get_string_value(archivoConfig, "NOMBRE_MEMORIA");
configuracion->nombreMemoria = strdup(nombreMemoria != NULL ? nombreMemoria : "NOMBRE_MEMORIA");
configuracion->maximosMarcosPorProceso = config_get_int_value(archivoConfig, "MAXIMO_MARCOS_POR_PROCESO");
configuracion->cantidadMarcos = config_get_int_value(archivoConfig, "CANTIDAD_MARCOS");
configuracion->tamanioMarcos = config_get_int_value(archivoConfig, "TAMANIO_MARCO");
configuracion->entradasTlb = config_get_int_value(archivoConfig, "ENTRADAS_TLB");
if (string_equals(config_get_string_value(archivoConfig, "TLB_HABILITADA"),"SI")){
configuracion->tlbHabilitada=1;
}
else if (string_equals(config_get_string_value(archivoConfig, "TLB_HABILITADA"),"NO")){
configuracion->tlbHabilitada=0;
}
configuracion->retardoMemoria = config_get_int_value(archivoConfig, "RETARDO_MEMORIA");
configuracion->algoritmo_reemplazo = strdup(config_get_string_value(archivoConfig, "ALGORITMO_REEMPLAZO"));
my_log_info("[INFO]: Archivo de configuracion leido correctamente\n");
logMsg = string_from_format("Archivo de configuracion leido correctamente\n");
puts(logMsg);
//config_destroy(archivoConfig);
}
}
static void test_int_to_malloced_string_base(void)
{
char *s;
s = int_to_malloced_string_base(0xdeadbeef, 16);
ASSERT(s != NULL);
ASSERT(string_equals("deadbeef", s));
free(s);
s = int_to_malloced_string_base(0xff, 2);
ASSERT(s != NULL);
ASSERT(string_equals("1111" "1111", s));
free(s);
}
static void test_int_to_string_base(void)
{
char buffer[100];
ASSERT(int_to_string_base(0, buffer, 2, 10) == 0);
ASSERT(string_equals(buffer, "0"));
ASSERT(int_to_string_base(0, buffer, 1, 10) == -1);
ASSERT(int_to_string_base(123, buffer, 3, 10) == -1);
ASSERT(int_to_string_base(123, buffer, 4, 10) == 0);
ASSERT(string_equals(buffer, "123"));
ASSERT(int_to_string_base(0xdeadbeef, buffer, 8, 16) == -1);
ASSERT(int_to_string_base(0xdeadbeef, buffer, 9, 16) == 0);
ASSERT(string_equals(buffer, "deadbeef"));
}
t_list* files_getEntriesOfDirectory(char* path) {
t_list* list = list_create();
DIR* dir;
struct dirent* ent;
if ((dir = opendir(path)) != NULL) {
while((ent = readdir(dir)) != NULL) {
char* name = ent->d_name;
if (!string_equals(name, ".") && !string_equals(name, ".."))
list_add(list, string_duplicate(name));
}
closedir(dir);
}
return list;
}
bool test_websocket_connect_error (Test *test)
{
NetWebsocket *websocket;
NetClientConnection connection;
NetClient *client;
TITLE ();
CATCH (!(websocket = net_websocket_create (&on_add,
&on_close,
&on_request)));
websocket->test.ConnectError = true;
// Connect with client.
CATCH (!(client = net_client_create (&client_on_connect,
&client_on_connect_error,
&client_on_error,
NULL)));
connection.ip = "127.0.0.1";
connection.port = 8888;
net_client_connect (client, &connection);
CATCH (!thread_signal_wait (&client_ready));
net_client_destroy (client);
net_websocket_destroy (websocket);
CATCH (error_at (0).error != ErrorFunctionCall);
CATCH (!string_equals (error_at (0).function, "server_on_connect"));
PASS ();
}
bool compile_project_execute_with_directory_name (CompileProject *project,
const char *directory_name,
bool bootstrap)
{
Compile *compile = NULL;
ListNode *node;
if (!project) {
compile_debug_invalid_arguments ();
return false;
}
if (!directory_name) {
compile_debug_invalid_arguments ();
return false;
}
for (node = list_last (project->sorted); !compile && node; node = list_previous (node)) {
if (string_equals (((Compile *)node->data)->directory->name, directory_name)) {
compile = node->data;
}
}
if (!compile) {
compile_debug_invalid_value ();
return false;
}
if (!included_libraries_are_up_to_date (project, compile)) {
return false;
}
if (!compile_execute (compile, bootstrap)) {
return false;
}
return true;
}
bool test_encode_base64 (Test *test)
{
char *base64;
char bytes[1024 * 16];
size_t i;
TITLE ();
CATCH (encode_base64 (NULL, 0));
CATCH (error_at (0).error != ErrorInvalidArgument);
CATCH (error_at (0).code != 1);
CATCH (encode_base64 ("", 0));
CATCH (error_at (0).error != ErrorInvalidArgument);
CATCH (error_at (0).code != 2);
memory_commit_limit (0);
CATCH (encode_base64 ("abc", 3));
CATCH (error_at (0).error != ErrorFunctionCall);
memory_commit_limit (ULLONG_MAX);
for (i = 0; i < 1000; i++) {
CATCH (!(base64 = encode_base64 ("any carnal pleasure.", 20)));
CATCH (!string_equals (base64, "YW55IGNhcm5hbCBwbGVhc3VyZS4="));
string_destroy (base64);
}
CATCH (!random_open ());
for (i = 0; i < 1000; i++) {
CATCH (!random_bytes ((unsigned char *)&bytes, 1024 * 16));
CATCH (!(base64 = encode_base64 (bytes, 1024 * 16)));
CATCH (string_length (base64) < 21848);
string_destroy (base64);
}
random_close ();
PASS ();
}
result test_string_equals_EmptyStrings() {
int passed = 0;
char* description = "string_equals(char*, char*) : 2EmptyString CASE";
passed = is_true(string_equals("", ""));
return (result){passed, description};
}
result test_string_equals_StringWithSameString() {
int passed = 0;
char* description = "string_equals(char*, char*) : StringWithSameString CASE";
passed = is_true(string_equals("abc", "abc"));
return (result){passed, description};
}
bool test_file_directory_open_current_2 (Test *test)
{
char *path;
Directory *directory;
TITLE ();
path = directory_current_path ();
CATCH (!(directory = directory_open_current ()));
CATCH (!string_equals (directory->path, path));
CATCH (!string_equals (directory->name, "app.test.lib.core"));
CATCH (directory->directories);
CATCH (directory->files);
CATCH (directory->modified == 0);
directory_close (directory);
string_destroy (path);
PASS ();
}
result test_string_equals_StringWithOtherString() {
int passed = 0;
char* description = "string_equals(char*, char*) : StringWithOtherString CASE";
passed = is_false(string_equals("abc", "efg"));
return (result){passed, description};
}
result test_string_equals_NULL() {
int passed = 0;
char* description = "string_equals(char*, char*) : NULL CASE";
passed = is_false(string_equals(0, 0));
return (result){passed, description};
}
bool TokenStream::nextEqualsString(const char* str, int lookahead)
{
if ((this->_position + lookahead) >= tokens.size())
return false;
Value next;
getNextStr(&next, lookahead);
return string_equals(&next, str);
}
Term* loop_find_done_call(Block* block)
{
for (int i=0; i < block->length(); i++) {
Term* term = block->get(i);
Value* methodName = term->getProp(s_method_name);
if (methodName && string_equals(methodName, "done"))
return term;
}
return NULL;
}
bool test_file_name_from_path (Test *test)
{
char *name;
TITLE ();
CATCH (!(name = file_name_from_path ("/")));
CATCH (!string_equals (name, "/"));
string_destroy (name);
CATCH (!(name = file_name_from_path ("/a")));
CATCH (!string_equals (name, "a"));
string_destroy (name);
CATCH (!(name = file_name_from_path ("/a/bb")));
CATCH (!string_equals (name, "bb"));
string_destroy (name);
CATCH (!(name = file_name_from_path ("/a/bb/ccc.dddd")));
CATCH (!string_equals (name, "ccc.dddd"));
string_destroy (name);
PASS ();
}
/* @builtin-bind { 'd', builtin_defun }, */
int builtin_defun(interpreter* interp) {
string name, body;
byte n1;
long_command* curr;
if (!stack_pop_strings(interp, 2, &body, &name)) UNDERFLOW;
/* If name is one character, it is a short name; if it is more than one
* character, it is a long name. An empty string is an error.
*/
if (!name->len) {
print_error("Empty command name");
goto error;
}
if (name->len == 1) {
n1 = string_data(name)[0];
/* Both pointers are in the same spot, so check either */
if (interp->commands[n1].cmd.native) {
print_error_s("Short command already exists", name);
goto error;
} else {
/* OK */
interp->commands[n1].is_native = 0;
interp->commands[n1].cmd.user = body;
free(name);
}
} else {
/* Long command name.
* First, check to see if it already exists.
*/
for (curr = interp->long_commands; curr; curr = curr->next) {
if (string_equals(name, curr->name)) {
print_error_s("Long command already exists", name);
goto error;
}
}
/* OK, add it */
curr = tmalloc(sizeof(long_command));
curr->name = name;
curr->cmd.is_native = 0;
curr->cmd.cmd.user = body;
curr->next = interp->long_commands;
interp->long_commands = curr;
}
return 1;
error:
/* Restore the stack and return failure */
stack_push(interp, name);
stack_push(interp, body);
return 0;
}
double test_accuracy(char *filename) {
language_classifier_data_set_t *data_set = language_classifier_data_set_init(filename);
if (data_set == NULL) {
log_error("Error creating data set\n");
exit(EXIT_FAILURE);
}
language_classifier_minibatch_t *minibatch;
uint32_t correct = 0;
uint32_t total = 0;
language_classifier_t *classifier = get_language_classifier();
trie_t *label_ids = trie_new_from_cstring_array(classifier->labels);
while (language_classifier_data_set_next(data_set)) {
char *address = char_array_get_string(data_set->address);
char *language = char_array_get_string(data_set->language);
uint32_t label_id;
if (!trie_get_data(label_ids, language, &label_id)) {
continue;
}
language_classifier_response_t *response = classify_languages(address);
if (response == NULL || response->num_languages == 0) {
printf("%s\tNULL\t%s\n", language, address);
continue;
}
char *top_lang = response->languages[0];
if (string_equals(top_lang, language)) {
correct++;
} else {
printf("%s\t%s\t%s\n", language, top_lang, address);
}
total++;
language_classifier_response_destroy(response);
}
log_info("total=%zu\n", total);
trie_destroy(label_ids);
return (double) correct / total;
}
Term* loop_find_iterator_advance(Block* block)
{
Term* iterator = loop_find_iterator(block);
for (int i=0; i < block->length(); i++) {
Term* term = block->get(i);
if (term->input(0) != iterator)
continue;
Value* methodName = term->getProp(s_method_name);
if (methodName && string_equals(methodName, "advance"))
return term;
}
return NULL;
}
bool hayQueEjecutarTests(int argc, char *argv[]) {
int i;
for (i = 0; i < argc; ++i) {
if (string_equals(argv[i], "test")) {
//printf("Hay que ejecutar tests\n");
return true;
}
}
//printf("No hay que ejecutar tests\n");
return false;
}
result test_string_copy_String() {
int passed = 0;
char* description = "string_copy(char*) : String CASE";
char* str = "abc";
char* cpy = string_copy(str);
passed = is_true(string_equals(str, cpy));
free(cpy);
return (result){passed, description};
}
Term* find_from_unique_name(Block* block, Value* name)
{
// O(n) search; this should be made more efficient.
for (int i=0; i < block->length(); i++) {
Term* term = block->get(i);
if (term == NULL)
continue;
if (string_equals(unique_name(term), name)) {
return term;
}
}
return NULL;
}
bool test_file_reader_create (Test *test)
{
FileReader *reader;
char *path;
TITLE ();
CATCH (!(path = directory_current_path ()));
CATCH (!string_append (&path, "/stage/file_reader/file"));
CATCH (!(reader = file_reader_create (path)));
CATCH (reader->size != 5);
CATCH (!string_equals ((const char *)reader->map, "test\n"));
file_reader_destroy (reader);
string_destroy (path);
PASS ();
}
int email_remove_email_from_recipients(struct email* email, char* addr)
{
int i;
int output = 0;
for (i = 0; i < MAX_RECIPIENTS; i++) {
if (email->to[i] && string_equals(email->to[i], addr)) {
SAFEFREE(email->to[i]);
int j;
for (j = i; j < MAX_RECIPIENTS; j++)
email->to[j] = email->to[j+1];
output = 1;
}
}
return output;
}
void assert_token_equals(const char *expected, const t_token *token)
{
char *string;
int r;
string = token_to_string(token);
r = string_equals(expected, string);
ASSERT(r);
if (!r)
{
print_string("Expected ");
print_string(expected);
print_string(", got ");
print_string(string);
print_string("\n");
}
free(string);
}
CIRCA_EXPORT caWorld* circa_initialize()
{
bootstrap_kernel();
caWorld* world = global_world();
Block* builtins = global_builtins_block();
//dump(builtins);
// Make sure there are no static errors in builtins. This shouldn't happen.
#if 0
if (has_static_errors(builtins)) {
std::cout << "Static errors found in kernel:" << std::endl;
dump(builtins);
Value msg;
print_static_errors_formatted(builtins, &msg);
dump(&msg);
}
#endif
// Load library paths from CIRCA_LIB_PATH
const char* libPathEnv = getenv("CIRCA_LIB_PATH");
if (libPathEnv != NULL) {
Value libPathStr;
set_string(&libPathStr, libPathEnv);
Value libPaths;
string_split(&libPathStr, ';', &libPaths);
for (int i=0; i < list_length(&libPaths); i++) {
Value* path = list_get(&libPaths, i);
if (string_equals(path, ""))
continue;
module_add_search_path(world, as_cstring(path));
}
}
log_msg(0, "finished circa_initialize");
world->bootstrapStatus = s_Done;
return world;
}
