path: root/driver/test-mlstring.c

/* 
 * (c) 2007, Quest Software, Inc. All rights reserved.
 *
 * This file is part of XScreenSaver,
 * Copyright (c) 1993-2004 Jamie Zawinski <jwz@jwz.org>
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation.  No representations are made about the suitability of this
 * software for any purpose.  It is provided "as is" without express or 
 * implied warranty.
 */

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#include "mlstring.c"  /* hokey, but whatever */

#define WRAP_WIDTH_PX 100

#undef Bool
#undef True
#undef False
typedef int Bool;
#define True 1
#define False 0

#define SKIPPED -1
#define SUCCESS 0
#define FAILURE 1

#define FAIL(msg, ...)                 \
  do {                                 \
    ++failcount;                       \
    fprintf(stderr, "[FAIL] ");        \
    fprintf(stderr, msg, __VA_ARGS__); \
    putc('\n', stderr);                \
    return FAILURE;                    \
  } while (0)

#define SUCCEED(testname)                          \
  do {                                             \
    fprintf(stderr, "[SUCCESS] %s\n", (testname)); \
  } while (0)

#define SKIP(testname)                             \
  do {                                             \
    fprintf(stderr, "[SKIPPED] %s\n", (testname)); \
  } while (0)

extern mlstring* mlstring_allocate(const char *msg);
extern void mlstring_wrap(mlstring *mstr, XFontStruct *font, Dimension width);

static int failcount = 0;

static char *mlstring_to_cstr(const mlstring *mlstr) {
  char *cstr;
  size_t cstrlen = 0, alloclen = 1024;
  const struct mlstr_line *line;

  cstr = malloc(alloclen);
  if (!cstr)
    return NULL;
  cstr[0] = '\0';

  for (line = mlstr->lines; line; line = line->next_line) {
    /* Extend the buffer if necessary. */
    if (cstrlen + strlen(line->line) + 1 > alloclen) {
      cstr = realloc(cstr, alloclen *= 2);
      if (!cstr)
	return NULL;
    }

    /* If this is not the first line */
    if (line != mlstr->lines) {
      /* Append a newline character */
      cstr[cstrlen] = '\n';
      ++cstrlen;
      cstr[cstrlen] = '\0';
    }

    strcat(cstr, line->line);
    cstrlen += strlen(line->line);
  }
  return cstr;
}

/* Pass -1 for expect_min or expect_exact to not check that value.
 * expect_empty_p means an empty line is expected at some point in the string.
 * Also ensures that the string was not too wide after wrapping. */
static int mlstring_expect_lines(const mlstring *mlstr, int expect_min, int expect_exact, Bool expect_empty_p)
{
  int count;
  Bool got_empty_line = False;
  const struct mlstr_line *line = mlstr->lines;

  for (count = 0; line; line = line->next_line) {
    if (line->line[0] == '\0') {
      if (!expect_empty_p)
	FAIL("Not expecting empty lines, but got one on line %d of [%s]", count + 1, mlstring_to_cstr(mlstr));
      got_empty_line = True;
    }
    ++count;
  }

  if (expect_empty_p && !got_empty_line)
    FAIL("Expecting an empty line, but none found in [%s]", mlstring_to_cstr(mlstr));

  if (expect_exact != -1 && expect_exact != count)
    FAIL("Expected %d lines, got %d", expect_exact, count);
  
  if (expect_min != -1 && count < expect_min)
    FAIL("Expected at least %d lines, got %d", expect_min, count);

  return SUCCESS;
}

static int mlstring_expect(const char *msg, int expect_lines, const mlstring *mlstr, Bool expect_empty_p)
{
  char *str, *str_top;
  const struct mlstr_line *cur;
  int linecount = 0;

  /* Duplicate msg so we can chop it up */
  str_top = strdup(msg);
  if (!str_top)
    return SKIPPED;

  /* Replace all newlines with NUL */
  str = str_top;
  while ((str = strchr(str, '\n')))
    *str++ = '\0';

  /* str is now used to point to the expected string */
  str = str_top;

  for (cur = mlstr->lines; cur; cur = cur->next_line)
    {
      ++linecount;
      if (strcmp(cur->line, str))
	FAIL("lines didn't match; expected [%s], got [%s]", str, cur->line);

      str += strlen(str) + 1; /* Point to the next expected string */
    }

  free(str_top);

  return mlstring_expect_lines(mlstr, -1, expect_lines, expect_empty_p);
}

/* Ensures that the width has been set properly after wrapping */
static int check_width(const char *msg, const mlstring *mlstr) {
  if (mlstr->overall_width == 0)
    FAIL("Overall width was zero for string [%s]", msg);

  if (mlstr->overall_width > WRAP_WIDTH_PX)
    FAIL("Overall width was %hu but the maximum wrap width was %d", mlstr->overall_width, WRAP_WIDTH_PX);

  return SUCCESS;
}

/* FAIL() actually returns the wrong return codes in main, but it
 * prints a message which is what we want. */

#define TRY_NEW(str, numl, expect_empty)                      \
  do {                                                        \
    mlstr = mlstring_allocate((str));                         \
    if (!mlstr)                                               \
      FAIL("%s", #str);                                       \
    if (SUCCESS == mlstring_expect((str), (numl), mlstr, (expect_empty))) \
      SUCCEED(#str);                                          \
    free(mlstr);                                              \
  } while (0)

/* Expects an XFontStruct* font, and tries to wrap to 100px */
#define TRY_WRAP(str, minl, expect_empty)                        \
  do {                                                           \
    mltest = mlstring_allocate((str));                           \
    if (!mltest)                                                 \
      SKIP(#str);                                                \
    else {                                                       \
      mlstring_wrap(mltest, font, WRAP_WIDTH_PX);                \
      check_width((str), mltest);                                \
      if (SUCCESS == mlstring_expect_lines(mltest, (minl), -1, (expect_empty)))  \
	SUCCEED(#str);                                           \
      free(mltest);                                              \
      mltest = NULL;                                             \
    }                                                            \
  } while (0)


/* Ideally this function would use stub functions rather than real Xlib.
 * Then it would be possible to test for exact line counts, which would be
 * more reliable.
 * It also doesn't handle Xlib errors.
 *
 * Don't print anything based on the return value of this function, it only
 * returns a value so that I can use the FAIL() macro without warning.
 *
 * Anyone who understands this function wins a cookie ;)
 */
static int test_wrapping(void)
{
  Display *dpy = NULL;
  XFontStruct *font = NULL;
  mlstring *mltest = NULL;
  int ok = 0;
  int chars_per_line, chars_first_word, i;
  
  const char *test_short = "a";
  const char *test_hardwrap = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
  const char *test_withnewlines = "a\nb";
  char *test_softwrap = NULL;

  dpy = XOpenDisplay(NULL);
  if (!dpy)
    goto end;
  
  font = XLoadQueryFont(dpy, "fixed");
  if (!font)
    goto end;

  TRY_WRAP(test_short, 1, False);
  TRY_WRAP(test_hardwrap, 2, False);
  TRY_WRAP(test_withnewlines, 2, False);

  /* See if wrapping splits on word boundaries like it should */
  chars_per_line = WRAP_WIDTH_PX / font->max_bounds.width;
  if (chars_per_line < 3)
    goto end;

  /* Allocate for 2 lines + \0 */
  test_softwrap = malloc(chars_per_line * 2 + 1);
  if (!test_softwrap)
    goto end;

  /* 2 = strlen(' a'); that is, the minimum space required to start a new word
   * on the same line. */
  chars_first_word = chars_per_line - 2;

  for (i = 0; i < chars_first_word; ++i) {
    test_softwrap[i] = 'a'; /* first word */
    test_softwrap[i + chars_per_line] = 'b'; /* second word */
  }
  /* space between first & second words */
  test_softwrap[chars_first_word] = ' ';
  /* first char of second word (last char of first line) */
  test_softwrap[chars_first_word + 1] = 'b';
  /* after second word */
  test_softwrap[chars_per_line * 2] = '\0';

  mltest = mlstring_allocate(test_softwrap);
  mlstring_wrap(mltest, font, WRAP_WIDTH_PX);

  /* reusing 'i' for a moment here to make freeing mltest easier */
  i = strlen(mltest->lines->line);
  free(mltest);

  if (i != chars_first_word)
    FAIL("Soft wrap failed, expected the first line to be %d chars, but it was %d.", chars_first_word, i);
  SUCCEED("Soft wrap");

  ok = 1;

end:
  if (test_softwrap)
    free(test_softwrap);

  if (font)
    XFreeFont(dpy, font);

  if (dpy)
    XCloseDisplay(dpy);

  if (!ok)
    SKIP("wrapping");

  return ok ? SUCCESS : SKIPPED; /* Unused, actually */
}


int main(int argc, char *argv[])
{
  const char *oneline = "1Foo";
  const char *twolines = "2Foo\nBar";
  const char *threelines = "3Foo\nBar\nWhippet";
  const char *trailnewline = "4Foo\n";
  const char *trailnewlines = "5Foo\n\n";
  const char *embeddednewlines = "6Foo\n\nBar";
  mlstring *mlstr;

  TRY_NEW(oneline, 1, False);
  TRY_NEW(twolines, 2, False);
  TRY_NEW(threelines, 3, False);
  TRY_NEW(trailnewline, 2, True);
  TRY_NEW(trailnewlines, 3, True);
  TRY_NEW(embeddednewlines, 3, True);

  (void) test_wrapping();

  fprintf(stdout, "%d test failures.\n", failcount);

  return !!failcount;
}

/* vim:ts=8:sw=2:noet
 */