[perl5.git] / ext / re / t / regop.t

#!./perl

BEGIN {
    require Config;
    if (($Config::Config{'extensions'} !~ /\bre\b/) ){
	print "1..0 # Skip -- Perl configured without re module\n";
	exit 0;
    }
}

use strict;
BEGIN { require "../../t/test.pl"; }
our $NUM_SECTS;
chomp(my @strs= grep { !/^\s*\#/ } <DATA>);
my $out = runperl(progfile => "t/regop.pl", stderr => 1 );
# VMS currently embeds linefeeds in the output.
$out =~ s/\cJ//g if $^O == 'VMS';
my @tests = grep { /\S/ } split /(?=Compiling REx)/, $out;
# on debug builds we get an EXECUTING... message in there at the top
shift @tests
    if $tests[0] =~ /EXECUTING.../;

plan( @tests + 2 + ( @strs - grep { !$_ or /^---/ } @strs ));

is( scalar @tests, $NUM_SECTS,
    "Expecting output for $NUM_SECTS patterns" );
ok( defined $out, 'regop.pl returned something defined' );

$out ||= "";
my $test= 1;
foreach my $testout ( @tests ) {
    my ( $pattern )= $testout=~/Compiling REx "([^"]+)"/;
    ok( $pattern, "Pattern for test " . ($test++) );
    my $diaged;
    while (@strs) {
        local $_= shift @strs;
        last if !$_
             or /^---/;
        next if /^\s*#/;
        s/^\s+//;
        s/\s+$//;
        ok( $testout=~/\Q$_\E/, "$_: /$pattern/" )
            or do {
                !$diaged++ and diag("PATTERN: /$pattern/\n\n"
		    . "EXPECTED:\n$_\n\n"
		    . "WITHIN GOT:\n$testout");
            };
    }
}

# The format below is simple. Each line is an exact
# string that must be found in the output.
# Lines starting the # are comments.
# Lines starting with --- are separators indicating
# that the tests for this result set are finished.
# If you add a test make sure you update $NUM_SECTS
# the commented output is just for legacy/debugging purposes
BEGIN{ $NUM_SECTS= 6 }

__END__
#Compiling REx "X(A|[B]Q||C|D)Y"
#size 34
#first at 1
#   1: EXACT <X>(3)
#   3: OPEN1(5)
#   5:   TRIE-EXACT(21)
#        [Words:5 Chars:5 Unique:5 States:6 Start-Class:A-D]
#          <A>
#          <BQ>
#          <>
#          <C>
#          <D>
#  21: CLOSE1(23)
#  23: EXACT <Y>(25)
#  25: END(0)
#anchored "X" at 0 floating "Y" at 1..3 (checking floating) minlen 2
#Guessing start of match, REx "X(A|[B]Q||C|D)Y" against "XY"...
#Found floating substr "Y" at offset 1...
#Found anchored substr "X" at offset 0...
#Guessed: match at offset 0
#Matching REx "X(A|[B]Q||C|D)Y" against "XY"
#  Setting an EVAL scope, savestack=140
#   0 <> <XY>              |  1:  EXACT <X>
#   1 <X> <Y>              |  3:  OPEN1
#   1 <X> <Y>              |  5:  TRIE-EXACT
#                                 matched empty string...
#   1 <X> <Y>              | 21:  CLOSE1
#   1 <X> <Y>              | 23:  EXACT <Y>
#   2 <XY> <>              | 25:  END
#Match successful!
#%MATCHED%
#Freeing REx: "X(A|[B]Q||C|D)Y"
Compiling REx "X(A|[B]Q||C|D)Y"
[A-D]
TRIE-EXACT
<BQ>
matched empty string
Match successful!
Found floating substr "Y" at offset 1...
Found anchored substr "X" at offset 0...
Guessed: match at offset 0
checking floating
minlen 2
S:1/6   
W:5
L:0/2
C:5/5
%MATCHED%
---
#Compiling REx "[f][o][o][b][a][r]"
#size 67
#first at 1
#   1: EXACT <foobar>(13)
#  13: END(0)
#anchored "foobar" at 0 (checking anchored isall) minlen 6
#Guessing start of match, REx "[f][o][o][b][a][r]" against "foobar"...
#Found anchored substr "foobar" at offset 0...
#Guessed: match at offset 0
#Freeing REx: "[f][o][o][b][a][r]"
foobar
checking anchored isall
minlen 6
anchored "foobar" at 0
Guessed: match at offset 0
Compiling REx "[f][o][o][b][a][r]"
Freeing REx: "[f][o][o][b][a][r]"
%MATCHED%
---
#Compiling REx ".[XY]."
#size 14
#first at 1
#   1: REG_ANY(2)
#   2: ANYOF[XY](13)
#  13: REG_ANY(14)
#  14: END(0)
#minlen 3
#%FAILED%
#Freeing REx: ".[XY]."
%FAILED%
minlen 3
---
# Compiling REx "(?:ABCP|ABCG|ABCE|ABCB|ABCA|ABCD)"
# Got 164 bytes for offset annotations.
#     TRIE(NATIVE): W:6 C:24 Uq:7 Min:4 Max:4
#       Char : Match Base  Ofs     A   B   C   P   G   E   D
#       State|---------------------------------------------------
#       #   1|       @   7 + 0[    2   .   .   .   .   .   .]
#       #   2|       @   7 + 1[    .   3   .   .   .   .   .]
#       #   3|       @   7 + 2[    .   .   4   .   .   .   .]
#       #   4|       @   A + 0[    9   8   0   5   6   7   A]
#       #   5| W   1 @   0 
#       #   6| W   2 @   0 
#       #   7| W   3 @   0 
#       #   8| W   4 @   0 
#       #   9| W   5 @   0 
#       #   A| W   6 @   0 
#     word_info N:(prev,char)= 1:(0,1) 2:(0,1) 3:(0,1) 4:(0,1) 5:(0,1) 6:(0,1)
# Final program:
#    1: EXACT <ABC> (3)
#    3: TRIEC-EXACT<S:4/10 W:6 L:1/1 C:24/7>[A-EGP] (20)
#       <P> 
#       <G> 
#       <E> 
#       <B> 
#       <A> 
#       <D> 
#   20: END (0)
# anchored "ABC" at 0 (checking anchored) minlen 4 
# Offsets: [20]
# 	1:4[3] 3:4[15] 19:32[0] 20:34[0] 
# Guessing start of match in sv for REx "(?:ABCP|ABCG|ABCE|ABCB|ABCA|ABCD)" against "ABCD"
# Found anchored substr "ABC" at offset 0...
# Guessed: match at offset 0
# Matching REx "(?:ABCP|ABCG|ABCE|ABCB|ABCA|ABCD)" against "ABCD"
#    0 <> <ABCD>               |  1:EXACT <ABC>(3)
#    3 <ABC> <D>               |  3:TRIEC-EXACT<S:4/10 W:6 L:1/1 C:24/7>[A-EGP](20)
#    3 <ABC> <D>               |    State:    4 Accepted:    0 Charid:  7 CP:  44 After State:    a
#    4 <ABCD> <>               |    State:    a Accepted:    1 Charid:  7 CP:   0 After State:    0
#                                   got 1 possible matches
#                                   TRIE matched word #6, continuing
#    4 <ABCD> <>               | 20:  END(0)
# Match successful!
# %MATCHED%
# Freeing REx: "(?:ABCP|ABCG|ABCE|ABCB|ABCA|ABCD)"
%MATCHED%
EXACT <ABC>
TRIEC-EXACT
[A-EGP]
S:4/10
W:6
L:1/1
C:24/7
minlen 4
(checking anchored)
anchored "ABC" at 0
---
#Compiling REx "(\.COM|\.EXE|\.BAT|\.CMD|\.VBS|\.VBE|\.JS|\.JSE|\.WSF|\.WSH|\.pyo|\.pyc|\.pyw|\.py)$"
#size 48 nodes first at 3
#first at 3
#rarest char
# at 0
#   1: OPEN1(3)
#   3:   EXACTF <.>(5)
#   5:   TRIE-EXACTF(45)
#        [Start:2 Words:14 Chars:54 Unique:18 States:29 Minlen:2 Maxlen:3 Start-Class:BCEJPVWbcejpvw]
#          <.COM>
#          ...  yada yada ... (dmq)
#          <.py>
#  45: CLOSE1(47)
#  47: EOL(48)
#  48: END(0)
#floating ""$ at 3..4 (checking floating) stclass "EXACTF <.>" minlen 3
#Offsets: [48]
#        1:1[1] 3:2[1] 5:2[81] 45:83[1] 47:84[1] 48:85[0]
#Guessing start of match, REx "(\.COM|\.EXE|\.BAT|\.CMD|\.VBS|\.VBE|\.JS|\.JSE|\.WSF|\.WSH|..." against "D:dev/perl/ver/28321_/perl.exe"...
#Found floating substr ""$ at offset 30...
#Starting position does not contradict /^/m...
#Does not contradict STCLASS...
#Guessed: match at offset 26
#Matching REx "(\.COM|\.EXE|\.BAT|\.CMD|\.VBS|\.VBE|\.JS|\.JSE|\.WSF|\.WSH|\.pyo|\.pyc|\.pyw|\.py)$..." against ".exe"
#Matching stclass "EXACTF <.>" against ".exe"
#  Setting an EVAL scope, savestack=140
#  26 <21_/perl> <.exe>    |  1:  OPEN1
#  26 <21_/perl> <.exe>    |  3:  EXACTF <.>
#  27 <21_/perl.> <exe>    |  5:  TRIE-EXACTF
#                                 only one match : #2 <.EXE>
#  30 <21_/perl.exe> <>    | 45:    CLOSE1
#  30 <21_/perl.exe> <>    | 47:    EOL
#  30 <21_/perl.exe> <>    | 48:    END
#Match successful!
#POP STATE(1)
#%MATCHED%
#Freeing REx: "(\\.COM|\\.EXE|\\.BAT|\\.CMD|\\.VBS|\\.VBE|\\.JS|\\.JSE|\\."......
%MATCHED%
floating ""$ at 3..4 (checking floating)
#1:1[1] 3:2[1] 5:2[64] 45:83[1] 47:84[1] 48:85[0]
#stclass EXACTF <.> minlen 3
#Found floating substr ""$ at offset 30...
#Does not contradict STCLASS...
#Guessed: match at offset 26
#Matching stclass EXACTF <.> against ".exe"
---
#Compiling REx "[q]"
#size 3 nodes Got 28 bytes for offset annotations.
#first at 1
#Final program:
#   1: EXACT <q>(3)
#   3: END(0)
#anchored "q" at 0 (checking anchored isall) minlen 1
#Offsets: [3]
#        1:1[3] 3:4[0]
#Guessing start of match, REx "[q]" against "q"...
#Found anchored substr "q" at offset 0...
#Guessed: match at offset 0
#%MATCHED%
#Freeing REx: "[q]"
Got 28 bytes for offset annotations.
Offsets: [3]
1:1[3] 3:4[0]
%MATCHED%        
Freeing REx: "[q]"
Commit	Line	Data
3dab1dad YO	1	#!./perl
	2
	3	BEGIN {
8e11feef RGS	4	require Config;
	5	if (($Config::Config{'extensions'} !~ /\bre\b/) ){
	6	print "1..0 # Skip -- Perl configured without re module\n";
	7	exit 0;
	8	}
3dab1dad YO	9	}
	10
	11	use strict;
2adbc9b6	12	BEGIN { require "../../t/test.pl"; }
07be1b83 YO	13	our $NUM_SECTS;
07be1b83 YO	14	chomp(my @strs= grep { !/^\s*\#/ } <DATA>);
2adbc9b6	15	my $out = runperl(progfile => "t/regop.pl", stderr => 1 );
a8d5f2f3	16	# VMS currently embeds linefeeds in the output.
788ee426	17	$out =~ s/\cJ//g if $^O == 'VMS';
07be1b83 YO	18	my @tests = grep { /\S/ } split /(?=Compiling REx)/, $out;
	19	# on debug builds we get an EXECUTING... message in there at the top
	20	shift @tests
	21	if $tests[0] =~ /EXECUTING.../;
3dab1dad	22
07be1b83	23	plan( @tests + 2 + ( @strs - grep { !$_ or /^---/ } @strs ));
3dab1dad	24
07be1b83 YO	25	is( scalar @tests, $NUM_SECTS,
	26	"Expecting output for $NUM_SECTS patterns" );
	27	ok( defined $out, 'regop.pl returned something defined' );
3dab1dad	28
07be1b83 YO	29	$out \|\|= "";
	30	my $test= 1;
	31	foreach my $testout ( @tests ) {
	32	my ( $pattern )= $testout=~/Compiling REx "([^"]+)"/;
	33	ok( $pattern, "Pattern for test " . ($test++) );
1e2e3d02	34	my $diaged;
8e11feef	35	while (@strs) {
07be1b83 YO	36	local $_= shift @strs;
	37	last if !$_
	38	or /^---/;
	39	next if /^\s*#/;
	40	s/^\s+//;
	41	s/\s+$//;
1e2e3d02 YO	42	ok( $testout=~/\Q$_\E/, "$_: /$pattern/" )
1e2e3d02 YO	43	or do {
2e64971a DM	44	!$diaged++ and diag("PATTERN: /$pattern/\n\n"
	45	. "EXPECTED:\n$_\n\n"
	46	. "WITHIN GOT:\n$testout");
1e2e3d02	47	};
8e11feef RGS	48	}
8e11feef RGS	49	}
3dab1dad	50
07be1b83 YO	51	# The format below is simple. Each line is an exact
	52	# string that must be found in the output.
	53	# Lines starting the # are comments.
b7b1e41b	54	# Lines starting with --- are separators indicating
07be1b83 YO	55	# that the tests for this result set are finished.
	56	# If you add a test make sure you update $NUM_SECTS
	57	# the commented output is just for legacy/debugging purposes
	58	BEGIN{ $NUM_SECTS= 6 }
	59
3dab1dad YO	60	__END__
	61	#Compiling REx "X(A\|[B]Q\|\|C\|D)Y"
	62	#size 34
	63	#first at 1
	64	# 1: EXACT <X>(3)
	65	# 3: OPEN1(5)
	66	# 5: TRIE-EXACT(21)
	67	# [Words:5 Chars:5 Unique:5 States:6 Start-Class:A-D]
	68	# <A>
	69	# <BQ>
	70	# <>
	71	# <C>
	72	# <D>
	73	# 21: CLOSE1(23)
	74	# 23: EXACT <Y>(25)
	75	# 25: END(0)
	76	#anchored "X" at 0 floating "Y" at 1..3 (checking floating) minlen 2
	77	#Guessing start of match, REx "X(A\|[B]Q\|\|C\|D)Y" against "XY"...
	78	#Found floating substr "Y" at offset 1...
	79	#Found anchored substr "X" at offset 0...
	80	#Guessed: match at offset 0
	81	#Matching REx "X(A\|[B]Q\|\|C\|D)Y" against "XY"
	82	# Setting an EVAL scope, savestack=140
	83	# 0 <> <XY> \| 1: EXACT <X>
	84	# 1 <X> <Y> \| 3: OPEN1
	85	# 1 <X> <Y> \| 5: TRIE-EXACT
	86	# matched empty string...
	87	# 1 <X> <Y> \| 21: CLOSE1
	88	# 1 <X> <Y> \| 23: EXACT <Y>
	89	# 2 <XY> <> \| 25: END
	90	#Match successful!
	91	#%MATCHED%
	92	#Freeing REx: "X(A\|[B]Q\|\|C\|D)Y"
	93	Compiling REx "X(A\|[B]Q\|\|C\|D)Y"
1e2e3d02	94	[A-D]
3dab1dad YO	95	TRIE-EXACT
	96	<BQ>
	97	matched empty string
	98	Match successful!
	99	Found floating substr "Y" at offset 1...
	100	Found anchored substr "X" at offset 0...
	101	Guessed: match at offset 0
	102	checking floating
	103	minlen 2
1e2e3d02 YO	104	S:1/6
	105	W:5
	106	L:0/2
	107	C:5/5
3dab1dad YO	108	%MATCHED%
	109	---
	110	#Compiling REx "[f][o][o][b][a][r]"
	111	#size 67
	112	#first at 1
	113	# 1: EXACT <foobar>(13)
	114	# 13: END(0)
	115	#anchored "foobar" at 0 (checking anchored isall) minlen 6
	116	#Guessing start of match, REx "[f][o][o][b][a][r]" against "foobar"...
	117	#Found anchored substr "foobar" at offset 0...
	118	#Guessed: match at offset 0
	119	#Freeing REx: "[f][o][o][b][a][r]"
	120	foobar
	121	checking anchored isall
	122	minlen 6
	123	anchored "foobar" at 0
	124	Guessed: match at offset 0
	125	Compiling REx "[f][o][o][b][a][r]"
	126	Freeing REx: "[f][o][o][b][a][r]"
	127	%MATCHED%
	128	---
	129	#Compiling REx ".[XY]."
	130	#size 14
	131	#first at 1
	132	# 1: REG_ANY(2)
	133	# 2: ANYOF[XY](13)
	134	# 13: REG_ANY(14)
	135	# 14: END(0)
	136	#minlen 3
	137	#%FAILED%
	138	#Freeing REx: ".[XY]."
	139	%FAILED%
	140	minlen 3
	141	---
1e2e3d02 YO	142	# Compiling REx "(?:ABCP\|ABCG\|ABCE\|ABCB\|ABCA\|ABCD)"
	143	# Got 164 bytes for offset annotations.
	144	# TRIE(NATIVE): W:6 C:24 Uq:7 Min:4 Max:4
	145	# Char : Match Base Ofs A B C P G E D
	146	# State\|---------------------------------------------------
	147	# # 1\| @ 7 + 0[ 2 . . . . . .]
	148	# # 2\| @ 7 + 1[ . 3 . . . . .]
	149	# # 3\| @ 7 + 2[ . . 4 . . . .]
	150	# # 4\| @ A + 0[ 9 8 0 5 6 7 A]
	151	# # 5\| W 1 @ 0
	152	# # 6\| W 2 @ 0
	153	# # 7\| W 3 @ 0
	154	# # 8\| W 4 @ 0
	155	# # 9\| W 5 @ 0
	156	# # A\| W 6 @ 0
2e64971a	157	# word_info N:(prev,char)= 1:(0,1) 2:(0,1) 3:(0,1) 4:(0,1) 5:(0,1) 6:(0,1)
1e2e3d02	158	# Final program:
2e64971a DM	159	# 1: EXACT <ABC> (3)
2e64971a DM	160	# 3: TRIEC-EXACT<S:4/10 W:6 L:1/1 C:24/7>[A-EGP] (20)
de734bd5 A	161	# <P>
	162	# <G>
	163	# <E>
	164	# <B>
	165	# <A>
	166	# <D>
2e64971a	167	# 20: END (0)
1e2e3d02 YO	168	# anchored "ABC" at 0 (checking anchored) minlen 4
	169	# Offsets: [20]
	170	# 1:4[3] 3:4[15] 19:32[0] 20:34[0]
	171	# Guessing start of match in sv for REx "(?:ABCP\|ABCG\|ABCE\|ABCB\|ABCA\|ABCD)" against "ABCD"
	172	# Found anchored substr "ABC" at offset 0...
	173	# Guessed: match at offset 0
	174	# Matching REx "(?:ABCP\|ABCG\|ABCE\|ABCB\|ABCA\|ABCD)" against "ABCD"
	175	# 0 <> <ABCD> \| 1:EXACT <ABC>(3)
	176	# 3 <ABC> <D> \| 3:TRIEC-EXACT<S:4/10 W:6 L:1/1 C:24/7>[A-EGP](20)
	177	# 3 <ABC> <D> \| State: 4 Accepted: 0 Charid: 7 CP: 44 After State: a
2e64971a	178	# 4 <ABCD> <> \| State: a Accepted: 1 Charid: 7 CP: 0 After State: 0
1e2e3d02	179	# got 1 possible matches
2e64971a DM	180	# TRIE matched word #6, continuing
2e64971a DM	181	# 4 <ABCD> <> \| 20: END(0)
1e2e3d02 YO	182	# Match successful!
	183	# %MATCHED%
	184	# Freeing REx: "(?:ABCP\|ABCG\|ABCE\|ABCB\|ABCA\|ABCD)"
3dab1dad YO	185	%MATCHED%
3dab1dad YO	186	EXACT <ABC>
1e2e3d02 YO	187	TRIEC-EXACT
1e2e3d02 YO	188	[A-EGP]
1e2e3d02 YO	189	S:4/10
	190	W:6
	191	L:1/1
	192	C:24/7
3dab1dad	193	minlen 4
1e2e3d02 YO	194	(checking anchored)
1e2e3d02 YO	195	anchored "ABC" at 0
07be1b83 YO	196	---
	197	#Compiling REx "(\.COM\|\.EXE\|\.BAT\|\.CMD\|\.VBS\|\.VBE\|\.JS\|\.JSE\|\.WSF\|\.WSH\|\.pyo\|\.pyc\|\.pyw\|\.py)$"
	198	#size 48 nodes first at 3
	199	#first at 3
	200	#rarest char
	201	# at 0
	202	# 1: OPEN1(3)
	203	# 3: EXACTF <.>(5)
	204	# 5: TRIE-EXACTF(45)
	205	# [Start:2 Words:14 Chars:54 Unique:18 States:29 Minlen:2 Maxlen:3 Start-Class:BCEJPVWbcejpvw]
	206	# <.COM>
	207	# ... yada yada ... (dmq)
	208	# <.py>
	209	# 45: CLOSE1(47)
	210	# 47: EOL(48)
	211	# 48: END(0)
	212	#floating ""$ at 3..4 (checking floating) stclass "EXACTF <.>" minlen 3
	213	#Offsets: [48]
	214	# 1:1[1] 3:2[1] 5:2[81] 45:83[1] 47:84[1] 48:85[0]
	215	#Guessing start of match, REx "(\.COM\|\.EXE\|\.BAT\|\.CMD\|\.VBS\|\.VBE\|\.JS\|\.JSE\|\.WSF\|\.WSH\|..." against "D:dev/perl/ver/28321_/perl.exe"...
	216	#Found floating substr ""$ at offset 30...
	217	#Starting position does not contradict /^/m...
	218	#Does not contradict STCLASS...
	219	#Guessed: match at offset 26
	220	#Matching REx "(\.COM\|\.EXE\|\.BAT\|\.CMD\|\.VBS\|\.VBE\|\.JS\|\.JSE\|\.WSF\|\.WSH\|\.pyo\|\.pyc\|\.pyw\|\.py)$..." against ".exe"
	221	#Matching stclass "EXACTF <.>" against ".exe"
	222	# Setting an EVAL scope, savestack=140
	223	# 26 <21_/perl> <.exe> \| 1: OPEN1
	224	# 26 <21_/perl> <.exe> \| 3: EXACTF <.>
	225	# 27 <21_/perl.> <exe> \| 5: TRIE-EXACTF
	226	# only one match : #2 <.EXE>
	227	# 30 <21_/perl.exe> <> \| 45: CLOSE1
	228	# 30 <21_/perl.exe> <> \| 47: EOL
	229	# 30 <21_/perl.exe> <> \| 48: END
	230	#Match successful!
	231	#POP STATE(1)
	232	#%MATCHED%
	233	#Freeing REx: "(\\.COM\|\\.EXE\|\\.BAT\|\\.CMD\|\\.VBS\|\\.VBE\|\\.JS\|\\.JSE\|\\."......
	234	%MATCHED%
	235	floating ""$ at 3..4 (checking floating)
0abd0d78 YO	236	#1:1[1] 3:2[1] 5:2[64] 45:83[1] 47:84[1] 48:85[0]
	237	#stclass EXACTF <.> minlen 3
	238	#Found floating substr ""$ at offset 30...
	239	#Does not contradict STCLASS...
	240	#Guessed: match at offset 26
	241	#Matching stclass EXACTF <.> against ".exe"
07be1b83 YO	242	---
07be1b83 YO	243	#Compiling REx "[q]"
3e6d27d5	244	#size 3 nodes Got 28 bytes for offset annotations.
07be1b83 YO	245	#first at 1
	246	#Final program:
	247	# 1: EXACT <q>(3)
	248	# 3: END(0)
	249	#anchored "q" at 0 (checking anchored isall) minlen 1
3e6d27d5	250	#Offsets: [3]
07be1b83 YO	251	# 1:1[3] 3:4[0]
	252	#Guessing start of match, REx "[q]" against "q"...
	253	#Found anchored substr "q" at offset 0...
	254	#Guessed: match at offset 0
	255	#%MATCHED%
	256	#Freeing REx: "[q]"
3e6d27d5 KW	257	Got 28 bytes for offset annotations.
3e6d27d5 KW	258	Offsets: [3]
07be1b83 YO	259	1:1[3] 3:4[0]
07be1b83 YO	260	%MATCHED%
2adbc9b6	261	Freeing REx: "[q]"