mongrel_esi 0.4.0

data/ext/esi/test/test.c

@@ -0,0 +1,373 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <regex.h>
+#include <fcntl.h>
+#include <unistd.h> /* for write */
+#define DEBUG
+#include "parser.h"
+
+#ifdef DEBUG
+#define TRACE()  fprintf(stderr, "> %s:%d:%s\n", __FILE__, __LINE__, __FUNCTION__)
+#else
+#define TRACE() 
+#endif
+
+
+/*
+ * TagInfo is used for collecting tags and asserting we have generated the correct tag names
+ */
+typedef struct _TagInfo {
+  char *name;
+  ESIAttribute *attributes;
+  struct _TagInfo *next;
+}TagInfo;
+
+static
+TagInfo* tag_info_new( const char *name, size_t len, ESIAttribute *attributes )
+{
+  TagInfo *ti = (TagInfo*)malloc(sizeof(TagInfo));
+  ti->name = esi_strndup( name, len );
+  ti->attributes = esi_attribute_copy( attributes );
+  ti->next = NULL;
+  return ti;
+}
+
+static
+void tag_info_free( TagInfo *ti )
+{
+  TagInfo *ptr = NULL;
+  while( ti ){
+    free( ti->name );
+    if( ti->attributes ) esi_attribute_free( ti->attributes );
+    ptr = ti->next; /* save the next pointer */
+    free( ti );
+    ti = ptr;
+  }
+}
+
+static int verify_string( const char *str, const char *str_value, int line, const char *test_name )
+{
+  int str_len = strlen( str );
+  int str_value_length = strlen( str_value ); 
+
+  if( str_len != str_value_length || strcmp( str, str_value ) ){
+    printf( "Strings are not equal\n\"%s\":%d\n!=\n\"%s\":%d\nat %s:%d\n", str, str_len, str_value, str_value_length, test_name, line );
+    return 1;
+  }
+  return 0;
+}
+
+static int verify_match_string( const char *expr, const char *str_value, int line, const char *test_name )
+{
+  int status;
+  regex_t reg_expr;
+  regcomp( &reg_expr, expr, REG_EXTENDED|REG_NOSUB );
+  status = regexec( &reg_expr, str_value, (size_t) 0, NULL, 0 );
+  regfree( &reg_expr );
+  if( status != 0 ){
+    printf( "No matching %s expression found in '%s' at %s:%d ", expr, str_value, test_name, line );
+    return 1;
+  }
+  return 0;
+}
+
+static int verify_no_match_string( const char *expr, const char *str_value, int line, const char *test_name )
+{
+  int status;
+  regex_t reg_expr;
+  regcomp( &reg_expr, expr, REG_EXTENDED|REG_NOSUB );
+  status = regexec( &reg_expr, str_value, (size_t) 0, NULL, 0 );
+  regfree( &reg_expr );
+  if( status == 0 ){
+    printf( "Found matching %s expression found in '%s' at %s:%d ", expr, str_value, test_name, line );
+    return 1;
+  }
+  return 0;
+}
+
+static int verify_true( int expr, int line, const char *test_name )
+{
+  if( !expr ){
+    printf( "Expression is not true at %s:%d\n", test_name, line );
+    return 1;
+  }
+  return 0;
+}
+
+static int start_tag_count = 0;
+static int end_tag_count = 0;
+static TagInfo *detected_start_tags = NULL; /* store parsed start tags from each test */
+static TagInfo *detected_end_tags = NULL; /* store parsed end tags from each test */
+
+static
+TagInfo *add_detected_tag( TagInfo *tags, TagInfo *ti )
+{
+  if( tags ){
+    TagInfo *next = tags;
+    TagInfo *prev = NULL;
+    while( next ){
+      prev = next;
+      next = next->next;
+    }
+    prev->next = ti;
+  }
+  else{
+    tags = ti;
+  }
+  return tags;
+}
+
+static 
+void free_detected_tags()
+{
+  if( detected_start_tags ){
+    tag_info_free( detected_start_tags );
+  }
+  if( detected_end_tags ){
+    tag_info_free( detected_end_tags );
+  }
+  detected_end_tags = NULL;
+  detected_start_tags = NULL;
+}
+
+static void start_tag_handler( const void *data,
+                               const char *name_start,
+                               size_t name_length,
+                               ESIAttribute *attributes,
+                               void *user_data )
+{
+  ESIAttribute *attr = attributes;
+  ++start_tag_count;
+  detected_start_tags = add_detected_tag( detected_start_tags, tag_info_new( name_start, name_length, attributes ) );
+}
+static void end_tag_handler( const void *data,  const char *name_start, size_t name_length, void *user_data )
+{
+  ++end_tag_count;
+  detected_end_tags = add_detected_tag( detected_end_tags, tag_info_new( name_start, name_length, NULL ) );
+}
+
+static void output_handler( const void *data, size_t size, void *user_data )
+{
+  write( (int)user_data, data, size );
+}
+
+static void feed_data( ESIParser *parser, const char *data )
+{
+//  printf( "feeding: %s\n", data );
+  esi_parser_execute( parser, data, strlen(data) );
+}
+
+#define TEST_INIT \
+  int fd;  \
+  struct stat st;  \
+  char *output = NULL;  \
+  size_t output_size;  \
+  int status = 0;\
+  start_tag_count = 0; \
+  end_tag_count = 0; \
+  printf( "%s: ", __FUNCTION__ ); \
+  esi_parser_init( parser ); \
+ \
+  esi_parser_start_tag_handler( parser, start_tag_handler ); \
+  esi_parser_end_tag_handler( parser, end_tag_handler ); \
+ \
+  unlink( "output.html" ); \
+  fd = open( "output.html", O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);  \
+  parser->user_data = (void*)fd; \
+  esi_parser_output_handler( parser, output_handler );
+
+#define TEST_WITH_FILE(file)\
+  int size = 0;\
+  FILE *input = NULL;\
+  char buffer[16]; /* intentially using a small buffer size */\
+  TEST_INIT\
+\
+  input = fopen( file, "r" );\
+  if( !input ){\
+    printf( "Failed to open %s\n", file );\
+    return;\
+  }\
+\
+  while( (size = fread( buffer, sizeof(char), 15, input )) > 0 ){\
+    esi_parser_execute( parser, buffer, size );\
+  }\
+\
+  fclose( input );
+
+#define TEST_PREPARE_ASSERTIONS \
+  esi_parser_finish( parser ); \
+ \
+  close( fd ); \
+ \
+  fd = open( "output.html", O_RDONLY ); \
+  fstat( fd, &st ); \
+  output_size = st.st_size; \
+  output = (char*)malloc(sizeof(char)*(output_size+1)); \
+  read( fd, output, output_size ); \
+  output[output_size] = '\0'; \
+  close( fd ); \
+  TagInfo *start_tags = detected_start_tags; \
+  TagInfo *end_tags = detected_end_tags;
+
+#define TEST_FINISH\
+  free( output ); \
+  free_detected_tags(); \
+  if( status ){ \
+    printf( "FAILED\n" ); \
+  }else{ \
+    printf( "PASSED\n" ); \
+  }
+#define ASSERT_EQUAL( s1, s2 )\
+  status |= verify_string( s1, s2, __LINE__, __FUNCTION__ )
+
+#define ASSERT_MATCH( regex, str )\
+  status |= verify_match_string( regex, str, __LINE__, __FUNCTION__ )
+#define ASSERT_NO_MATCH( regex, str )\
+  status |= verify_no_match_string( regex, str, __LINE__, __FUNCTION__ )
+#define ASSERT_TRUE( expr )\
+  status |= verify_true( expr, __LINE__, __FUNCTION__ )
+
+#define ASSERT_TAG_NAME( name )\
+  ASSERT_NO_MATCH( "<", name ); \
+  ASSERT_MATCH( "esi:", name );
+
+#define ASSERT_TAG_NAMES( tags )\
+  while( tags  ){ \
+    ASSERT_TAG_NAME( tags->name );\
+    tags = tags->next;\
+  }
+
+static void test_simple_parser_input( ESIParser *parser )
+{
+  TEST_INIT
+
+  feed_data( parser, "<p>some input</p><esi:include/>some more input\nsome input<esi:include timeout='10' src='hello'/>some more input" );
+
+  TEST_PREPARE_ASSERTIONS
+
+  ASSERT_EQUAL( "<p>some input</p>some more input\nsome inputsome more input", output );
+  ASSERT_TRUE( start_tag_count == 2 );
+  ASSERT_TRUE( end_tag_count == 2 );
+  
+  ASSERT_TAG_NAMES( start_tags )
+  ASSERT_TAG_NAMES( end_tags )
+
+  TEST_FINISH
+}
+
+static void test_chunked_input( ESIParser *parser )
+{
+  TEST_INIT
+
+  feed_data( parser, "some input<" );
+  feed_data( parser, "e" );
+  feed_data( parser, "s" );
+  feed_data( parser, "i" );
+  feed_data( parser, ":" );
+  feed_data( parser, "i" );
+  feed_data( parser, "n" );
+  feed_data( parser, "lin" );
+  feed_data( parser, "e" );
+  feed_data( parser, " " );
+  feed_data( parser, "s" );
+  feed_data( parser, "rc" );
+  feed_data( parser, "=" );
+  feed_data( parser, "'hel" );
+  feed_data( parser, "lo'" );
+  feed_data( parser, "/" );
+  feed_data( parser, ">some more input\nsome input" );
+  feed_data( parser, "<esi:comment text=" );
+  feed_data( parser, "'hello'/>some more input" );
+ 
+  TEST_PREPARE_ASSERTIONS
+
+  ASSERT_EQUAL( "some inputsome more input\nsome inputsome more input", output );
+  ASSERT_TRUE( start_tag_count == 2 );
+  ASSERT_TRUE( end_tag_count == 2 );
+  
+  ASSERT_TAG_NAMES( start_tags )
+  ASSERT_TAG_NAMES( end_tags )
+
+  TEST_FINISH
+}
+#define ESI_SAMPLE "../../../test/unit/esi-sample.html" 
+static void test_sample_input( ESIParser *parser )
+{
+  TEST_WITH_FILE( ESI_SAMPLE );
+
+  TEST_PREPARE_ASSERTIONS
+
+  ASSERT_MATCH("  <div class=\"body\">", output );
+  ASSERT_MATCH("    <div>some content</div>", output);
+  ASSERT_MATCH("<em>Support for em tags since they have an initial start sequence similar to and &lt;esi: start/end sequence</em>", output );
+  ASSERT_NO_MATCH("<esi:", output);
+
+  ASSERT_TRUE( start_tag_count == 13 );
+  ASSERT_TRUE( end_tag_count == 13 );
+
+  ASSERT_TAG_NAMES( start_tags )
+  ASSERT_TAG_NAMES( end_tags )
+
+  TEST_FINISH
+}
+
+static void test_line_by_line( ESIParser *parser )
+{
+  TEST_INIT
+
+  feed_data( parser, "<html><head><body><esi:include timeout='1' max-age='600+600' src=\"hello\"/>some more input" );
+  feed_data( parser, "some input<esi:include \nsrc='hello'/>some more input\nsome input<esi:include src=\"hello\"/>some more input" );
+  feed_data( parser, "some input<esi:inline src='hello'/>some more input\nsome input<esi:comment text='hello'/>some more input" );
+  feed_data( parser, "<p>some input</p><esi:include src='hello'/>some more input\nsome input<esi:include src='hello'/>some more input" );
+  feed_data( parser, "</body></html>" );
+
+  TEST_PREPARE_ASSERTIONS
+
+  ASSERT_EQUAL("<html><head><body>some more inputsome inputsome more input\nsome inputsome more inputsome inputsome more input\nsome inputsome more input<p>some input</p>some more input\nsome inputsome more input</body></html>", output );
+  ASSERT_TRUE( start_tag_count == 7 );
+  ASSERT_TRUE( end_tag_count == 7 );
+  
+  ASSERT_TAG_NAMES( start_tags )
+  ASSERT_TAG_NAMES( end_tags )
+
+  TEST_FINISH
+}
+
+#define ESI_LARGE_FILE "../../../test/integration/docs/index.html" 
+static void test_large_file( ESIParser *parser )
+{
+  TEST_WITH_FILE( ESI_LARGE_FILE );
+
+  TEST_PREPARE_ASSERTIONS
+
+  ASSERT_NO_MATCH("<esi:", output);
+
+  ASSERT_MATCH( "</html>", output );
+
+  ASSERT_TAG_NAMES( start_tags )
+  ASSERT_TAG_NAMES( end_tags )
+
+  TEST_FINISH
+}
+
+int main( int argc, char **argv )
+{
+  ESIParser *parser = esi_parser_new();
+
+  test_simple_parser_input( parser );
+
+  test_chunked_input( parser );
+
+  test_sample_input( parser );
+
+  test_line_by_line( parser );
+  
+  test_large_file( parser );
+
+  esi_parser_free( parser );
+
+  return 0;
+}

data/ext/esi/test1.rb

@@ -0,0 +1,56 @@
+require 'esi'
+
+output = ""
+# TODO: support passing output stream to new
+p = ESI::CParser.new
+
+# TODO: support attributes
+p.start_tag_handler do|tag_name, attrs|
+  puts "Start: #{tag_name} #{attrs.inspect}"
+end
+
+p.end_tag_handler do|tag_name|
+  puts "End: #{tag_name}"
+end
+
+p.output_handler do|data|
+  output << data
+end
+
+p.process "<html><head><body><esi:include timeout='1' max-age='600+600' src=\"hello\"/>some more input"
+p.process "some input<esi:include \nsrc='hello'/>some more input\nsome input<esi:include src=\"hello\"/>some more input"
+p.process "some input<esi:inline src='hello'/>some more input\nsome input<esi:comment text='hello'/>some more input"
+p.process "<p>some input</p><esi:include src='hello'/>some more input\nsome input<esi:include src='hello'/>some more input"
+p.process "</body></html>"
+p.finish
+expected = %Q(<html><head><body>some more inputsome inputsome more input
+some inputsome more inputsome inputsome more input
+some inputsome more input<p>some input</p>some more input
+some inputsome more input</body></html>) 
+
+if( expected !=  output )
+  puts "Failed output was different from the expected"
+  puts "Expected: #{expected}"
+  puts "\n"
+  puts "Actual: #{output}"
+  exit(1)
+end
+
+p.esi_tag = "hello"
+
+if( "hello" != p.esi_tag )
+  puts "Failed esi_tag could not be set"
+  exit(1)
+end
+
+p.depth = 1
+if( 1 != p.depth )
+  puts "Failed depth could not be set"
+  exit(1)
+end
+
+puts "PASSED"
+
+p = nil
+
+GC.start

data/ext/esi/test2.rb

@@ -0,0 +1,45 @@
+require 'esi'
+
+10.times do
+  output = ""
+  # TODO: support passing output stream to new
+  p = ESI::CParser.new
+
+  # TODO: support attributes
+  p.start_tag_handler do|tag_name, attrs|
+    puts "Start: #{tag_name} #{attrs.inspect}"
+  end
+
+  p.end_tag_handler do|tag_name|
+    puts "End: #{tag_name}"
+  end
+
+  p.output_handler do|data|
+    output << data
+  end
+
+  p.process "<html><head><body><esi:include timeout='1' max-age='600+600' src=\"hello\"/>some more input"
+  p.process "some input<esi:include \nsrc='hello'/>some more input\nsome input<esi:include src=\"hello\"/>some more input"
+  p.process "some input<esi:inline src='hello'/>some more input\nsome input<esi:comment text='hello'/>some more input"
+  p.process "<p>some input</p><esi:include src='hello'/>some more input\nsome input<esi:include src='hello'/>some more input"
+  p.process "</body></html>"
+  p.finish
+  expected = %Q(<html><head><body>some more inputsome inputsome more input
+some inputsome more inputsome inputsome more input
+some inputsome more input<p>some input</p>some more input
+some inputsome more input</body></html>) 
+
+  if( expected !=  output )
+    puts "Failed output was different from the expected"
+    puts "Expected: #{expected}"
+    puts "\n"
+    puts "Actual: #{output}"
+    exit(1)
+  end
+end
+
+puts "PASSED"
+
+#p = nil
+
+GC.start