mathematical 1.2.0 → 1.2.1

data/ext/mathematical/mtex2MML/tests/clar/print.h

@@ -0,0 +1,66 @@
+
+static void clar_print_init(int test_count, int suite_count, const char *suite_names)
+{
+	(void)test_count;
+	printf("Loaded %d suites: %s\n", (int)suite_count, suite_names);
+	printf("Started\n");
+}
+
+static void clar_print_shutdown(int test_count, int suite_count, int error_count)
+{
+	(void)test_count;
+	(void)suite_count;
+	(void)error_count;
+
+	printf("\n\n");
+	clar_report_errors();
+}
+
+static void clar_print_error(int num, const struct clar_error *error)
+{
+	printf("  %d) Failure:\n", num);
+
+	printf("%s::%s [%s:%d]\n",
+		error->suite,
+		error->test,
+		error->file,
+		error->line_number);
+
+	printf("  %s\n", error->error_msg);
+
+	if (error->description != NULL)
+		printf("  %s\n", error->description);
+
+	printf("\n");
+	fflush(stdout);
+}
+
+static void clar_print_ontest(const char *test_name, int test_number, enum cl_test_status status)
+{
+	(void)test_name;
+	(void)test_number;
+
+	switch(status) {
+	case CL_TEST_OK: printf("."); break;
+	case CL_TEST_FAILURE: printf("F"); break;
+	case CL_TEST_SKIP: printf("S"); break;
+	}
+
+	fflush(stdout);
+}
+
+static void clar_print_onsuite(const char *suite_name, int suite_index)
+{
+	if (_clar.report_suite_names)
+		printf("\n%s", suite_name);
+
+	(void)suite_index;
+}
+
+static void clar_print_onabort(const char *msg, ...)
+{
+	va_list argp;
+	va_start(argp, msg);
+	vfprintf(stderr, msg, argp);
+	va_end(argp);
+}

data/ext/mathematical/mtex2MML/tests/clar/sandbox.h

@@ -0,0 +1,139 @@
+static char _clar_path[4096];
+
+static int
+is_valid_tmp_path(const char *path)
+{
+	STAT_T st;
+
+	if (stat(path, &st) != 0)
+		return 0;
+
+	if (!S_ISDIR(st.st_mode))
+		return 0;
+
+	return (access(path, W_OK) == 0);
+}
+
+static int
+find_tmp_path(char *buffer, size_t length)
+{
+#ifndef _WIN32
+	static const size_t var_count = 5;
+	static const char *env_vars[] = {
+		"CLAR_TMP", "TMPDIR", "TMP", "TEMP", "USERPROFILE"
+ 	};
+
+ 	size_t i;
+
+	for (i = 0; i < var_count; ++i) {
+		const char *env = getenv(env_vars[i]);
+		if (!env)
+			continue;
+
+		if (is_valid_tmp_path(env)) {
+			strncpy(buffer, env, length);
+			return 0;
+		}
+	}
+
+	/* If the environment doesn't say anything, try to use /tmp */
+	if (is_valid_tmp_path("/tmp")) {
+		strncpy(buffer, "/tmp", length);
+		return 0;
+	}
+
+#else
+	DWORD env_len = GetEnvironmentVariable("CLAR_TMP", buffer, (DWORD)length);
+	if (env_len > 0 && env_len < (DWORD)length)
+		return 0;
+
+	if (GetTempPath((DWORD)length, buffer))
+		return 0;
+#endif
+
+	/* This system doesn't like us, try to use the current directory */
+	if (is_valid_tmp_path(".")) {
+		strncpy(buffer, ".", length);
+		return 0;
+	}
+
+	return -1;
+}
+
+static void clar_unsandbox(void)
+{
+	if (_clar_path[0] == '\0')
+		return;
+
+	chdir("..");
+
+	fs_rm(_clar_path);
+}
+
+static int build_sandbox_path(void)
+{
+#ifdef CLAR_TMPDIR
+	const char path_tail[] = CLAR_TMPDIR "_XXXXXX";
+#else
+	const char path_tail[] = "clar_tmp_XXXXXX";
+#endif
+
+	size_t len;
+
+	if (find_tmp_path(_clar_path, sizeof(_clar_path)) < 0)
+		return -1;
+
+	len = strlen(_clar_path);
+
+#ifdef _WIN32
+	{ /* normalize path to POSIX forward slashes */
+		size_t i;
+		for (i = 0; i < len; ++i) {
+			if (_clar_path[i] == '\\')
+				_clar_path[i] = '/';
+		}
+	}
+#endif
+
+	if (_clar_path[len - 1] != '/') {
+		_clar_path[len++] = '/';
+	}
+
+	strncpy(_clar_path + len, path_tail, sizeof(_clar_path) - len);
+
+#if defined(__MINGW32__)
+	if (_mktemp(_clar_path) == NULL)
+		return -1;
+
+	if (mkdir(_clar_path, 0700) != 0)
+		return -1;
+#elif defined(_WIN32)
+	if (_mktemp_s(_clar_path, sizeof(_clar_path)) != 0)
+		return -1;
+
+	if (mkdir(_clar_path, 0700) != 0)
+		return -1;
+#else
+	if (mkdtemp(_clar_path) == NULL)
+		return -1;
+#endif
+
+	return 0;
+}
+
+static int clar_sandbox(void)
+{
+	if (_clar_path[0] == '\0' && build_sandbox_path() < 0)
+		return -1;
+
+	if (chdir(_clar_path) != 0)
+		return -1;
+
+	return 0;
+}
+
+const char *clar_sandbox_path(void)
+{
+	return _clar_path;
+}
+

data/ext/mathematical/mtex2MML/tests/clar_test.h

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) Vicent Marti. All rights reserved.
+ *
+ * This file is part of clar, distributed under the ISC license.
+ * For full terms see the included COPYING file.
+ */
+#ifndef __CLAR_TEST__
+#define __CLAR_TEST__
+
+/* Import the standard clar helper functions */
+#include "clar.h"
+
+/* Your custom shared includes / defines here */
+extern int global_test_counter;
+
+#include "helpers.h"
+#include "../src/mtex2MML.h"
+#include "deps/file2str/file2str.h"
+
+#endif

data/ext/mathematical/mtex2MML/tests/cornercases.c

@@ -0,0 +1,45 @@
+#include "clar.h"
+#include "clar_test.h"
+#include <stdio.h>
+
+static char *fixture_tex;
+static char *fixture_mml;
+static char *result;
+
+void test_cornercases__initialize(void)
+{
+  global_test_counter++;
+}
+
+void test_cornercases__cleanup(void)
+{
+  if (fixture_tex != NULL) {
+    free(fixture_tex);
+  }
+
+  if (fixture_mml != NULL) {
+    free(fixture_mml);
+  }
+
+  if (result != NULL) {
+    free(result);
+  }
+}
+
+void test_cornercases__broken_up_inline_env(void)
+{
+  fixture_tex = read_fixture_tex("cornercases/broken_up_inline_env.txt");
+  fixture_mml = read_fixture_mml("cornercases/broken_up_inline_env.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_cornercases__some_crazy_alignment(void)
+{
+  fixture_tex = read_fixture_tex("cornercases/some_crazy_alignment.txt");
+  fixture_mml = read_fixture_mml("cornercases/some_crazy_alignment.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}

data/ext/mathematical/mtex2MML/tests/deps/file2str/file2str.c

@@ -0,0 +1,64 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char *file2strl(
+    const char *path,
+    unsigned int *file_len_out
+)
+{
+    FILE *file;
+
+    if (!(file = fopen(path, "rb")))
+    {
+        fprintf(stderr, "Unable to open file %s\n", path);
+        return NULL;
+    }
+
+    if (-1 == fseek(file, 0, SEEK_END))
+    {
+        fprintf(stderr, "Unable to seek file %s\n", path);
+        return NULL;
+    }
+
+    unsigned long file_len;
+    if (-1 == (file_len = ftell(file)))
+    {
+        fprintf(stderr, "Unable to ftell() file %s\n", path);
+        return NULL;
+    }
+
+    if (-1 == fseek(file, 0, SEEK_SET))
+    {
+        fprintf(stderr, "Unable to seek file %s\n", path);
+        return NULL;
+    }
+
+    char *contents;
+    if (!(contents = malloc(file_len + 1)))
+    {
+        fprintf(stderr, "Memory error!\n");
+        fclose(file);
+        return NULL;
+    }
+
+    fread(contents, file_len, 1, file);
+    fclose(file);
+
+    contents[file_len] = '\0';
+
+    if (file_len_out)
+        *file_len_out = file_len + 1;
+
+    return contents;
+}
+
+char *file2str(
+    const char *path,
+    unsigned long *file_len_out
+)
+{
+    return file2strl(path,NULL);
+}
+

data/ext/mathematical/mtex2MML/tests/deps/file2str/file2str.h

@@ -0,0 +1,12 @@
+#ifndef FILE2STR_H
+#define FILE2STR_H
+
+/**
+ * @param path File's path.
+ * @param len Pointer to the length of the string returned
+ * @return string contents of file; otherwise NULL on error */
+char *file2strl(const char *path, unsigned int *len);
+
+char *file2str(const char *path);
+
+#endif /* FILE2STR_H */

data/ext/mathematical/mtex2MML/tests/deps/trim/trim.c

@@ -0,0 +1,24 @@
+char *
+trim(char *str)
+{
+  char *end;
+
+  // ltrim
+  while (isspace(*str)) {
+    str++;
+  }
+
+  if (*str == 0) // only spaces
+    return str;
+
+  // rtrim
+  end = str + strlen(str) - 1;
+  while (end > str && isspace(*end)) {
+    end--;
+  }
+
+  // null terminator
+  *(end+1) = 0;
+
+  return str;
+}

data/ext/mathematical/mtex2MML/tests/deps/trim/trim.h

@@ -0,0 +1,7 @@
+#ifndef __TRIM__
+#define __TRIM__
+
+char *
+trim(char *str);
+
+#endif /*__TRIM__*/

data/ext/mathematical/mtex2MML/tests/env.c

@@ -0,0 +1,333 @@
+#include "clar.h"
+#include "clar_test.h"
+#include <stdio.h>
+
+static char *fixture_tex;
+static char *fixture_mml;
+static char *result;
+
+void test_env__initialize(void)
+{
+  global_test_counter++;
+}
+
+void test_env__cleanup(void)
+{
+  if (fixture_tex != NULL) {
+    free(fixture_tex);
+  }
+
+  if (fixture_mml != NULL) {
+    free(fixture_mml);
+  }
+
+  if (result != NULL) {
+    free(result);
+  }
+}
+
+void test_env__matrix_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/matrix_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/matrix_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__matrix_no_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/matrix_no_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/matrix_no_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__matrix_no_lines(void)
+{
+  fixture_tex = read_fixture_tex("env/matrix_no_lines.txt");
+  fixture_mml = read_fixture_mml("env/matrix_no_lines.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__pmatrix_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/pmatrix_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/pmatrix_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__pmatrix_no_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/pmatrix_no_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/pmatrix_no_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__pmatrix_no_lines(void)
+{
+  fixture_tex = read_fixture_tex("env/pmatrix_no_lines.txt");
+  fixture_mml = read_fixture_mml("env/pmatrix_no_lines.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__bmatrix_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/bmatrix_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/bmatrix_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__bmatrix_no_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/bmatrix_no_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/bmatrix_no_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__bmatrix_no_lines(void)
+{
+  fixture_tex = read_fixture_tex("env/bmatrix_no_lines.txt");
+  fixture_mml = read_fixture_mml("env/bmatrix_no_lines.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__bbmatrix_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/bbmatrix_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/bbmatrix_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__bbmatrix_no_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/bbmatrix_no_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/bbmatrix_no_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__bbmatrix_no_lines(void)
+{
+  fixture_tex = read_fixture_tex("env/bbmatrix_no_lines.txt");
+  fixture_mml = read_fixture_mml("env/bbmatrix_no_lines.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__vmatrix_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/vmatrix_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/vmatrix_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__vmatrix_no_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/vmatrix_no_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/vmatrix_no_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__vmatrix_no_lines(void)
+{
+  fixture_tex = read_fixture_tex("env/vmatrix_no_lines.txt");
+  fixture_mml = read_fixture_mml("env/vmatrix_no_lines.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__vvmatrix_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/vvmatrix_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/vvmatrix_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__vvmatrix_no_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/vvmatrix_no_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/vvmatrix_no_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__vvmatrix_no_lines(void)
+{
+  fixture_tex = read_fixture_tex("env/vvmatrix_no_lines.txt");
+  fixture_mml = read_fixture_mml("env/vvmatrix_no_lines.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__smallmatrix_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/smallmatrix_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/smallmatrix_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__smallmatrix_no_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/smallmatrix_no_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/smallmatrix_no_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__smallmatrix_no_lines(void)
+{
+  fixture_tex = read_fixture_tex("env/smallmatrix_no_lines.txt");
+  fixture_mml = read_fixture_mml("env/smallmatrix_no_lines.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__aligned_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/aligned_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/aligned_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__aligned_no_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/aligned_no_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/aligned_no_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__aligned_no_lines(void)
+{
+  fixture_tex = read_fixture_tex("env/aligned_no_lines.txt");
+  fixture_mml = read_fixture_mml("env/aligned_no_lines.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__gathered_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/gathered_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/gathered_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__gathered_no_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/gathered_no_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/gathered_no_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__gathered_no_lines(void)
+{
+  fixture_tex = read_fixture_tex("env/gathered_no_lines.txt");
+  fixture_mml = read_fixture_mml("env/gathered_no_lines.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__split_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/split_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/split_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__split_no_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/split_no_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/split_no_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__split_no_lines(void)
+{
+  fixture_tex = read_fixture_tex("env/split_no_lines.txt");
+  fixture_mml = read_fixture_mml("env/split_no_lines.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__spaces_after_rowsep(void)
+{
+  fixture_tex = read_fixture_tex("env/spaces_after_rowsep.txt");
+  fixture_mml = read_fixture_mml("env/spaces_after_rowsep.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__cases_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/cases_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/cases_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__cases_no_ex_spacing(void)
+{
+  fixture_tex = read_fixture_tex("env/cases_no_ex_spacing.txt");
+  fixture_mml = read_fixture_mml("env/cases_no_ex_spacing.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}
+
+void test_env__cases_no_lines(void)
+{
+  fixture_tex = read_fixture_tex("env/cases_no_lines.txt");
+  fixture_mml = read_fixture_mml("env/cases_no_lines.html");
+  result = mtex2MML_parse(fixture_tex, strlen(fixture_tex));
+
+  cl_assert_equal_s(fixture_mml, result);
+}