[Templates-cvs] cvs commit: TT3/t/parser assign.t

[cvs@template-toolkit.org]

cvs         04/12/02 18:25:33

  Added:       t/parser assign.t
  Log:
  * added tests in t/parser/assign.t to test the various parser methods
    that parse assignments
  
  Revision  Changes    Path
  1.1                  TT3/t/parser/assign.t
  
  Index: assign.t
  ===================================================================
  #============================================================= -*-perl-*-
  #
  # t/parser/assign.t
  #
  # Test the Template::Parser module and the various methods to parse
  # assignments.
  #
  # Written by Andy Wardley <abw@wardley.org>
  #
  # This is free software; you can redistribute it and/or modify it
  # under the same terms as Perl itself.
  #
  # $Id: assign.t,v 1.1 2004/12/02 18:25:32 abw Exp $
  #
  #========================================================================
  
  use strict;
  use warnings;
  
  use lib qw( ./lib ../lib ../../lib );
  use Template::Parser;
  use Template::Generator::Debug;
  use Template::Test tests => 25, import => ':all';
  
  our $DEBUG = 
  $Template::Parser::DEBUG =
  grep(/^--?d(ebug)?/, @ARGV);
  
  my $ppkg = 'Template::Parser';
  my $gpkg = 'Template::Generator::Debug';
  
  my $parser = $ppkg->new() 
      || die $ppkg->error();
  ok( $parser, "created a parser" );
  
  my $method   = 'parse_assign_expr';
  my $required = 0;
  
  my $generator = $gpkg->new() 
      || die $gpkg->error();
  ok( $generator, "created a generator" );
  
  test_expect({
      handler => \&parse, 
      ok      => \&ok 
  });
  
  sub parse {
      my $test   = shift;
      my $input  = $test->{ input };
      my $result = '';
  
      if (my $new_method = (grep(/^parse_/, @{ $test->{ inflags } }))[0]) {
          if (UNIVERSAL::can($parser, $new_method)) {
              $method = $new_method;
          }
          else {
              die "invalid parser method: $new_method\n";
          }
      }
  
      if ($test->{ inflag }->{ required }) {
          $required = 1;
      }
      elsif ($test->{ inflag }->{ not_required }) {
          $required = 0;
      }
  
      my $expr = eval {
          $parser->$method(\$input, required => $required);
      };
      if ($expr) {
          $expr = $generator->generate($expr);
          die "generator failed: ", $generator->error()
              unless defined $expr;
      }
      elsif ($@) {
          my $error = ref($@) ? $@->info() : $@;
          $expr = "<ERROR:$error>";
      }
      else {
          $expr = '<DECLINED:' . $parser->error() . '>';
      }
      return $expr;
  }
  
  
  
  __END__
  
  #------------------------------------------------------------------------
  # parse_assign_expr()
  #------------------------------------------------------------------------
  
  -- test assign expression --
  -- parse_assign_expr --
  =10
  -- expect --
  <number:10>
  
  -- test assign with whitespace --
   =
   20
  -- expect --
  <number:20>
  
  -- test arrow assign --
  => 30
  -- expect --
  <number:30>
  
  -- test assign expression with comments --
  # comment before
  = # comment between
  40 # comment after
  -- expect --
  <number:40>
  
  -- test missing expression --
  =
  -- expect --
  <ERROR:missing expression after '='>
  
  -- test bad expression --
  = &
  -- expect --
  <ERROR:missing expression after '=' (got '&')>
  
  
  #------------------------------------------------------------------------
  # parse_ident_assign_expr()
  #------------------------------------------------------------------------
  
  -- test ident assign expression --
  -- parse_ident_assign_expr --
  foo=100
  -- expect --
  <foo:
    <number:100>
  >
  
  -- test missing assignment after ident --
  bar
  -- expect --
  <DECLINED:not an assignment>
  
  -- test missing expression after ident --
  bar=
  -- expect --
  <ERROR:missing expression after '='>
  
  -- test strings not allowed as idents --
  'foo' = 200
  -- expect --
  <DECLINED:not an identifier>
  
  -- test dotted variables are not allowed as idents --
  foo.bar = 205
  -- expect --
  <DECLINED:not an assignment>
  
  -- test missing assignment after ident required --
  -- required --
  bar
  -- expect --
  <ERROR:missing assignment after identifier 'bar'>
  
  -- test dotted variables are not allowed as idents req --
  foo.bar = 205
  -- expect --
  <ERROR:missing assignment after identifier 'foo' (got '.bar')>
  
  
  
  #------------------------------------------------------------------------
  # parse_key_assign_expr()
  #------------------------------------------------------------------------
  
  -- test key assign expression --
  -- parse_key_assign_expr --
  foo=210
  -- expect --
  [
    <ident:foo>
    <number:210>
  ]
  
  -- test single quoted strings are allowed as keys --
  'foo' = 220
  -- expect --
  [
    <squote:foo>
    <number:220>
  ]
  
  -- test double quoted strings are allowed as keys --
  "foo" = 230
  -- expect --
  [
    <dquote:
      <text:foo>
    >
    <number:230>
  ]
  
  -- test dotted variables are not allowed as keys --
  -- not_required --
  bar.baz = 240
  -- expect --
  <DECLINED:not an assignment>
  
  -- test missing assignment after key --
  bar
  -- expect --
  <DECLINED:not an assignment>
  
  -- test missing expression after key --
  bar=
  -- expect --
  <ERROR:missing expression after '='>
  
  -- test dotted variables are not allowed as keys req --
  -- required --
  bar.baz = 240
  -- expect --
  <ERROR:missing assignment after key 'bar' (got '.baz')>
  
  -- test required assignment after key --
  bar
  -- expect --
  <ERROR:missing assignment after key 'bar'>
  
  -- test required assignment after single quoted key --
  'bar'
  -- expect --
  <ERROR:missing assignment after key 'bar'>
  
  -- test required assignment after double quoted key --
  "bar$baz"
  -- expect --
  <ERROR:missing assignment after key "bar$baz">
  
  
  
  
  __END__
  
  # Local Variables:
  # mode: perl
  # perl-indent-level: 4
  # indent-tabs-mode: nil
  # End:
  #
  # vim: expandtab shiftwidth=4: