Result:
found more than 971 distributions - search limited to the first 2001 files matching your query
( run in 2.722 )
HTML-Data-Parser
view release on metacpan or search on metacpan
inc/YAML/Tiny.pm view on Meta::CPAN
die \"Did not provide a string to load";
}
# Byte order marks
# NOTE: Keeping this here to educate maintainers
# my %BOM = (
# "\357\273\277" => 'UTF-8',
# "\376\377" => 'UTF-16BE',
# "\377\376" => 'UTF-16LE',
# "\377\376\0\0" => 'UTF-32LE'
# "\0\0\376\377" => 'UTF-32BE',
# );
if ( $string =~ /^(?:\376\377|\377\376|\377\376\0\0|\0\0\376\377)/ ) {
die \"Stream has a non UTF-8 BOM";
} else {
# Strip UTF-8 bom if found, we'll just ignore it
$string =~ s/^\357\273\277//;
}
HTML-Embedded-Turtle
view release on metacpan or search on metacpan
inc/YAML/Tiny.pm view on Meta::CPAN
die \"Did not provide a string to load";
}
# Byte order marks
# NOTE: Keeping this here to educate maintainers
# my %BOM = (
# "\357\273\277" => 'UTF-8',
# "\376\377" => 'UTF-16BE',
# "\377\376" => 'UTF-16LE',
# "\377\376\0\0" => 'UTF-32LE'
# "\0\0\376\377" => 'UTF-32BE',
# );
if ( $string =~ /^(?:\376\377|\377\376|\377\376\0\0|\0\0\376\377)/ ) {
die \"Stream has a non UTF-8 BOM";
} else {
# Strip UTF-8 bom if found, we'll just ignore it
$string =~ s/^\357\273\277//;
}
HTML-Encapsulate
view release on metacpan or search on metacpan
lib/HTML/Encapsulate.pm view on Meta::CPAN
my ($words) = HTTP::Headers::Util::split_header_words($content_type);
my %param = @$words;
return $param{charset};
}
# 3) If there's a UTF BOM set, look for it
my $count = 0;
while (my ($enc, $bom) = $boms->[$count++, $count++])
{
return $enc
if $bom eq substr($chunk, 0, length $bom);
HTML-Encoding
view release on metacpan or search on metacpan
lib/HTML/Encoding.pm view on Meta::CPAN
# remember match length
$resu{$e} = length $bom if $text =~ /^(\Q$bom\E)/;
}
# does not start with BOM
return unless keys %resu;
# sort by match length, longest match first
my @sort = sort { $resu{$b} <=> $resu{$a} } keys %resu;
lib/HTML/Encoding.pm view on Meta::CPAN
return unless defined $text;
return unless length $text;
my @boms = encoding_from_byte_order_mark($text, encodings => $encodings);
# BOM determines encoding
return wantarray ? (bom => \@boms) : $boms[0] if @boms;
# no BOM
my @decls = xml_declaration_from_octets($text, encodings => $encodings);
foreach my $decl (@decls)
{
my $enco = encoding_from_xml_declaration($decl);
$resu{$enco}++ if defined $enco and length $enco;
lib/HTML/Encoding.pm view on Meta::CPAN
}
else
{
my @boms = encoding_from_byte_order_mark($text, encodings => $encodings);
# BOM determines encoding
return wantarray ? (bom => \@boms) : $boms[0] if @boms;
}
# no BOM
my @resu;
# sanity check to exclude e.g. UTF-32
my @first = encoding_from_first_chars($text, encodings => $encodings);
lib/HTML/Encoding.pm view on Meta::CPAN
of $options{encodings} or the list of default encodings if no
encodings are specified and match the beginning of the string against
any byte order mark octet sequence found.
The result can be ambiguous, for example qq(\xFF\xFE\x00\x00) could
be both, a complete BOM in UTF-32LE or a UTF-16LE BOM followed by a
U+0000 character. It is also possible that C<$octets> starts with
something that looks like a byte order mark but actually is not.
encoding_from_byte_order_mark sorts the list of possible encodings
by the length of their BOM octet sequence and returns in scalar
context only the encoding with the longest match, and all encodings
ordered by length of their BOM octet sequence in list context.
Examples:
+-------------------------+------------+-----------------------+
| Input | Encodings | Result |
lib/HTML/Encoding.pm view on Meta::CPAN
This might change in future versions, although this is not very
relevant for most applications as there should never be need to use
UTF-7 in the encoding list for existing documents.
If no BOM can be found it returns C<undef> in scalar context and an
empty list in list context. This routine should not be used with
strings with the UTF-8 flag turned on.
=item encoding_from_xml_declaration($declaration)
HTML-ExtractMain
view release on metacpan or search on metacpan
t/test_case_data/indymedia_feature.html view on Meta::CPAN
</div>
<p class="commenttext">*LE 15 FEVRIER 2010, PLUS DE 800 ACTIVISTES, DONT HUIT BOMSPOTTEURS BLOQUAIENT <br/>L'USINE ANGLAISE DE PRODUCTION DE BOMBES NUCLEAIRES* <br/>*voir_la_video* <br/><br/>*Plus de 800 activistes de toute l’Europe ont fermé l...
</div>
<div class="commentsbody">
<h3 class="commenttitle">Video of action at military base Volkel, the Netherlands</h3>
<p class="commentspost">
HTML-FormBuilder
view release on metacpan or search on metacpan
lib/HTML/FormBuilder/Select.pm view on Meta::CPAN
our $VERSION = '0.13'; ## VERSION
=head1 NAME
HTML::FormBuilder::Select - Select Element Handling for BOM Forms
=cut
=head1 Synopsis
HTML-FormatExternal
view release on metacpan or search on metacpan
devel/run.pl view on Meta::CPAN
my $str = HTML::FormatText::Elinks->format_file
('devel/base.html', base => 'http://localhost');
exit 0;
}
{
# BOM on input
# lynx recognises automatically
my $html = "<html><body><p>Hello world</p></body></html>\n";
require Encode;
$html = Encode::encode('utf-32',$html); # with BOM
# $html = "\xFF\xFE\x00\x00" . Encode::encode('utf-32le',$html); # with BOM
$html = ("\x20\x00\x00\x00" x 8) . $html; # BE spaces
print "HTML input string:\n";
IPC::Run::run(['hd'],'<',\$html, '>','/tmp/hd.txt');
IPC::Run::run(['cat'],'<','/tmp/hd.txt');
HTML-Gumbo
view release on metacpan or search on metacpan
lib/HTML/Gumbo.pm view on Meta::CPAN
Use it to hardcode a specific encoding.
$gumbo->parse( $octets, input_is => 'octets', encoding => 'latin-1' );
=item BOM
UTF-8/UTF-16 BOMs are checked.
=item C<encoding_content_type> argument
Encdoning from rransport layer, charset in content-type header.
HTML-HTML5-Builder
view release on metacpan or search on metacpan
inc/YAML/Tiny.pm view on Meta::CPAN
return $self->_error("Did not provide a string to load");
}
# Byte order marks
# NOTE: Keeping this here to educate maintainers
# my %BOM = (
# "\357\273\277" => 'UTF-8',
# "\376\377" => 'UTF-16BE',
# "\377\376" => 'UTF-16LE',
# "\377\376\0\0" => 'UTF-32LE'
# "\0\0\376\377" => 'UTF-32BE',
# );
if ( $string =~ /^(?:\376\377|\377\376|\377\376\0\0|\0\0\376\377)/ ) {
return $self->_error("Stream has a non UTF-8 BOM");
} else {
# Strip UTF-8 bom if found, we'll just ignore it
$string =~ s/^\357\273\277//;
}
HTML-HTML5-Microdata-Parser
view release on metacpan or search on metacpan
inc/YAML/Tiny.pm view on Meta::CPAN
return $self->_error("Did not provide a string to load");
}
# Byte order marks
# NOTE: Keeping this here to educate maintainers
# my %BOM = (
# "\357\273\277" => 'UTF-8',
# "\376\377" => 'UTF-16BE',
# "\377\376" => 'UTF-16LE',
# "\377\376\0\0" => 'UTF-32LE'
# "\0\0\376\377" => 'UTF-32BE',
# );
if ( $string =~ /^(?:\376\377|\377\376|\377\376\0\0|\0\0\376\377)/ ) {
return $self->_error("Stream has a non UTF-8 BOM");
} else {
# Strip UTF-8 bom if found, we'll just ignore it
$string =~ s/^\357\273\277//;
}
HTML-HTML5-Microdata-ToRDFa
view release on metacpan or search on metacpan
inc/YAML/Tiny.pm view on Meta::CPAN
return $self->_error("Did not provide a string to load");
}
# Byte order marks
# NOTE: Keeping this here to educate maintainers
# my %BOM = (
# "\357\273\277" => 'UTF-8',
# "\376\377" => 'UTF-16BE',
# "\377\376" => 'UTF-16LE',
# "\377\376\0\0" => 'UTF-32LE'
# "\0\0\376\377" => 'UTF-32BE',
# );
if ( $string =~ /^(?:\376\377|\377\376|\377\376\0\0|\0\0\376\377)/ ) {
return $self->_error("Stream has a non UTF-8 BOM");
} else {
# Strip UTF-8 bom if found, we'll just ignore it
$string =~ s/^\357\273\277//;
}
HTML-HTML5-Outline
view release on metacpan or search on metacpan
inc/YAML/Tiny.pm view on Meta::CPAN
return $self->_error("Did not provide a string to load");
}
# Byte order marks
# NOTE: Keeping this here to educate maintainers
# my %BOM = (
# "\357\273\277" => 'UTF-8',
# "\376\377" => 'UTF-16BE',
# "\377\376" => 'UTF-16LE',
# "\377\376\0\0" => 'UTF-32LE'
# "\0\0\376\377" => 'UTF-32BE',
# );
if ( $string =~ /^(?:\376\377|\377\376|\377\376\0\0|\0\0\376\377)/ ) {
return $self->_error("Stream has a non UTF-8 BOM");
} else {
# Strip UTF-8 bom if found, we'll just ignore it
$string =~ s/^\357\273\277//;
}
HTML-HTML5-Parser
view release on metacpan or search on metacpan
lib/HTML/HTML5/Parser/Charset/DecodeHandle.pm view on Meta::CPAN
onerror => $_[3] || sub {},
#onerror_set
};
if ($csdef->{uri}->{$XML_AUTO_CHARSET} or
$obj->{charset} eq $XML_AUTO_CHARSET) {
my $b = ''; # UTF-8 w/o BOM
$csdef = $HTML::HTML5::Parser::Charset::CharsetDef->{$PERL_CHARSET.'utf-8'};
$obj->{input_encoding} = 'UTF-8';
if (read $obj->{filehandle}, $b, 256) {
no warnings "substr";
no warnings "uninitialized";
lib/HTML/HTML5/Parser/Charset/DecodeHandle.pm view on Meta::CPAN
# \x4C\x6F\xA7\x94 EBCDIC
} # buffer
$obj->{byte_buffer} .= $b;
} # read
} elsif ($csdef->{uri}->{$XML_CHARSET.'utf-8'}) {
## BOM is optional.
my $b = '';
if (read $obj->{filehandle}, $b, 3) {
if ($b eq "\xEF\xBB\xBF") {
$obj->{has_bom} = 1;
} else {
$obj->{byte_buffer} .= $b;
}
}
$csdef = $HTML::HTML5::Parser::Charset::CharsetDef->{$PERL_CHARSET.'utf-8'}; # UTF-8 w/o BOM
} elsif ($csdef->{uri}->{$XML_CHARSET.'utf-16'}) {
## BOM is mandated.
my $b = '';
if (read $obj->{filehandle}, $b, 2) {
if ($b eq "\xFE\xFF") {
$obj->{has_bom} = 1; # UTF-16BE w/o BOM
$csdef = $HTML::HTML5::Parser::Charset::CharsetDef->{$PERL_CHARSET.'utf-16be'};
} elsif ($b eq "\xFF\xFE") {
$obj->{has_bom} = 1; # UTF-16LE w/o BOM
$csdef = $HTML::HTML5::Parser::Charset::CharsetDef->{$PERL_CHARSET.'utf-16le'};
} else {
$obj->{onerror}->(undef, 'no-bom-error', charset_uri => $obj->{charset});
$obj->{has_bom} = 0;
$obj->{byte_buffer} .= $b; # UTF-16BE w/o BOM
$csdef = $HTML::HTML5::Parser::Charset::CharsetDef->{$PERL_CHARSET.'utf-16be'};
}
} else {
$obj->{onerror}->(undef, 'no-bom-error', charset_uri => $obj->{charset});
$obj->{has_bom} = 0; # UTF-16BE w/o BOM
$csdef = $HTML::HTML5::Parser::Charset::CharsetDef->{$PERL_CHARSET.'utf-16be'};
}
}
if ($csdef->{uri}->{$XML_CHARSET.'iso-2022-jp'}) {
HTML-HTML5-ToText
view release on metacpan or search on metacpan
inc/YAML/Tiny.pm view on Meta::CPAN
die \"Did not provide a string to load";
}
# Byte order marks
# NOTE: Keeping this here to educate maintainers
# my %BOM = (
# "\357\273\277" => 'UTF-8',
# "\376\377" => 'UTF-16BE',
# "\377\376" => 'UTF-16LE',
# "\377\376\0\0" => 'UTF-32LE'
# "\0\0\376\377" => 'UTF-32BE',
# );
if ( $string =~ /^(?:\376\377|\377\376|\377\376\0\0|\0\0\376\377)/ ) {
die \"Stream has a non UTF-8 BOM";
} else {
# Strip UTF-8 bom if found, we'll just ignore it
$string =~ s/^\357\273\277//;
}
HTML-HTML5-Writer
view release on metacpan or search on metacpan
inc/YAML/Tiny.pm view on Meta::CPAN
die \"Did not provide a string to load";
}
# Byte order marks
# NOTE: Keeping this here to educate maintainers
# my %BOM = (
# "\357\273\277" => 'UTF-8',
# "\376\377" => 'UTF-16BE',
# "\377\376" => 'UTF-16LE',
# "\377\376\0\0" => 'UTF-32LE'
# "\0\0\376\377" => 'UTF-32BE',
# );
if ( $string =~ /^(?:\376\377|\377\376|\377\376\0\0|\0\0\376\377)/ ) {
die \"Stream has a non UTF-8 BOM";
} else {
# Strip UTF-8 bom if found, we'll just ignore it
$string =~ s/^\357\273\277//;
}
HTML-Microformats
view release on metacpan or search on metacpan
inc/YAML/Tiny.pm view on Meta::CPAN
die \"Did not provide a string to load";
}
# Byte order marks
# NOTE: Keeping this here to educate maintainers
# my %BOM = (
# "\357\273\277" => 'UTF-8',
# "\376\377" => 'UTF-16BE',
# "\377\376" => 'UTF-16LE',
# "\377\376\0\0" => 'UTF-32LE'
# "\0\0\376\377" => 'UTF-32BE',
# );
if ( $string =~ /^(?:\376\377|\377\376|\377\376\0\0|\0\0\376\377)/ ) {
die \"Stream has a non UTF-8 BOM";
} else {
# Strip UTF-8 bom if found, we'll just ignore it
$string =~ s/^\357\273\277//;
}
HTML-MyHTML
view release on metacpan or search on metacpan
Return: 1 (true) if encoding found, otherwise 0 (false)
=head3 encoding_detect_bom
Detect Unicode character encoding by BOM
Now available for detect UTF-8, UTF-16LE, UTF-16BE
# $text[in] text
# $out_encoding[out] detected encoding
HTML-Parser
view release on metacpan or search on metacpan
lib/HTML/HeadParser.pm view on Meta::CPAN
sub text
{
my($self, $text) = @_;
print "TEXT[$text]\n" if $DEBUG;
unless ($self->{first_chunk}) {
# drop Unicode BOM if found
if ($self->utf8_mode) {
$text =~ s/^\xEF\xBB\xBF//;
}
else {
$text =~ s/^\x{FEFF}//;
HTML-PodCodeReformat
view release on metacpan or search on metacpan
t/000-report-versions.t view on Meta::CPAN
return $self->_error("Did not provide a string to load");
}
# Byte order marks
# NOTE: Keeping this here to educate maintainers
# my %BOM = (
# "\357\273\277" => 'UTF-8',
# "\376\377" => 'UTF-16BE',
# "\377\376" => 'UTF-16LE',
# "\377\376\0\0" => 'UTF-32LE'
# "\0\0\376\377" => 'UTF-32BE',
# );
if ( $string =~ /^(?:\376\377|\377\376|\377\376\0\0|\0\0\376\377)/ ) {
return $self->_error("Stream has a non UTF-8 BOM");
} else {
# Strip UTF-8 bom if found, we'll just ignore it
$string =~ s/^\357\273\277//;
}
HTML-Transmorgify
view release on metacpan or search on metacpan
t/form_checksum.t view on Meta::CPAN
my $submit = Load($s_yaml);
chomp($output);
undef %HTML::Transmorgify::compiled;
my $res;
my $bomb = sub {
print STDERR "############################################ BOMB\n";
print STDERR "@_\n";
$onebad++;
local($HTML::Transmorgify::debug) = 1;
undef %HTML::Transmorgify::compiled;
pos($input) = 0;
HTML-Valid
view release on metacpan or search on metacpan
bind_match|5.003007||Viu
block_end|5.004000|5.004000|
block_gimme|5.004000|5.004000|u
blockhook_register|5.013003|5.013003|x
block_start|5.004000|5.004000|
BOM_UTF8|5.025005|5.003007|p
boolSV|5.004000|5.003007|p
boot_core_mro|5.009005||Viu
boot_core_PerlIO|5.007002||Viu
boot_core_UNIVERSAL|5.003007||Viu
_byte_dump_string|5.025006||cViu
#endif
#endif
#if 'A' == 65
#ifndef BOM_UTF8
# define BOM_UTF8 "\xEF\xBB\xBF"
#endif
#ifndef REPLACEMENT_CHARACTER_UTF8
# define REPLACEMENT_CHARACTER_UTF8 "\xEF\xBF\xBD"
#endif
#elif '^' == 95
#ifndef BOM_UTF8
# define BOM_UTF8 "\xDD\x73\x66\x73"
#endif
#ifndef REPLACEMENT_CHARACTER_UTF8
# define REPLACEMENT_CHARACTER_UTF8 "\xDD\x73\x73\x71"
#endif
#elif '^' == 176
#ifndef BOM_UTF8
# define BOM_UTF8 "\xDD\x72\x65\x72"
#endif
#ifndef REPLACEMENT_CHARACTER_UTF8
# define REPLACEMENT_CHARACTER_UTF8 "\xDD\x72\x72\x70"
#endif
HTML-Zoom-Parser-HH5P
view release on metacpan or search on metacpan
inc/YAML/Tiny.pm view on Meta::CPAN
die \"Did not provide a string to load";
}
# Byte order marks
# NOTE: Keeping this here to educate maintainers
# my %BOM = (
# "\357\273\277" => 'UTF-8',
# "\376\377" => 'UTF-16BE',
# "\377\376" => 'UTF-16LE',
# "\377\376\0\0" => 'UTF-32LE'
# "\0\0\376\377" => 'UTF-32BE',
# );
if ( $string =~ /^(?:\376\377|\377\376|\377\376\0\0|\0\0\376\377)/ ) {
die \"Stream has a non UTF-8 BOM";
} else {
# Strip UTF-8 bom if found, we'll just ignore it
$string =~ s/^\357\273\277//;
}
HTML5-DOM
view release on metacpan or search on metacpan
L<detect|/detect>
=back
Returns array with encoding id and new text without BOM, if success.
If fail, then encoding id equal HTML5::DOM::Encoding->NOT_DETERMINED.
my ($encoding_id, $new_text) = HTML5::DOM::Encoding::detectAuto("ололо");
my $encoding = HTML5::DOM::Encoding::id2name($encoding_id);
=head3 detectBomAndCut
my ($encoding_id, $new_text) = HTML5::DOM::Encoding::detectBomAndCut($text, $max_length = 0);
Returns array with encoding id and new text without BOM.
If fail, then encoding id equal HTML5::DOM::Encoding->NOT_DETERMINED.
my ($encoding_id, $new_text) = HTML5::DOM::Encoding::detectBomAndCut("\xEF\xBB\xBFололо");
my $encoding = HTML5::DOM::Encoding::id2name($encoding_id);
See L<detectByPrescanStream|/detectByPrescanStream>.
=head4 encoding_use_bom
Allow use detecding BOM to determine input HTML encoding. (default 1)
See L<detectBomAndCut|/detectBomAndCut>.
=head4 utf8
HTTP-LRDD
view release on metacpan or search on metacpan
inc/YAML/Tiny.pm view on Meta::CPAN
die \"Did not provide a string to load";
}
# Byte order marks
# NOTE: Keeping this here to educate maintainers
# my %BOM = (
# "\357\273\277" => 'UTF-8',
# "\376\377" => 'UTF-16BE',
# "\377\376" => 'UTF-16LE',
# "\377\376\0\0" => 'UTF-32LE'
# "\0\0\376\377" => 'UTF-32BE',
# );
if ( $string =~ /^(?:\376\377|\377\376|\377\376\0\0|\0\0\376\377)/ ) {
die \"Stream has a non UTF-8 BOM";
} else {
# Strip UTF-8 bom if found, we'll just ignore it
$string =~ s/^\357\273\277//;
}
HTTP-Message
view release on metacpan or search on metacpan
lib/HTTP/Message.pm view on Meta::CPAN
}
# time to start guessing
my $cref = $self->decoded_content(ref => 1, charset => "none");
# Unicode BOM
for ($$cref) {
return "UTF-8" if /^\xEF\xBB\xBF/;
return "UTF-32LE" if /^\xFF\xFE\x00\x00/;
return "UTF-32BE" if /^\x00\x00\xFE\xFF/;
return "UTF-16LE" if /^\xFF\xFE/;
HTTP-Promise
view release on metacpan or search on metacpan
lib/HTTP/Promise/Entity.pm view on Meta::CPAN
{
use strict;
use warnings;
warnings::register_categories( 'HTTP::Promise' );
use parent qw( Module::Generic );
use vars qw( $VERSION $EXCEPTION_CLASS $BOUNDARY_DELIMITER $BOM2ENC $ENC2BOM $BOM_RE
$BOM_MAX_LENGTH $DEFAULT_MIME_TYPE );
use Data::UUID;
use HTTP::Promise::Exception;
use HTTP::Promise::Headers;
use HTTP::Promise::Body;
use Module::Generic::HeaderValue;
lib/HTTP/Promise/Entity.pm view on Meta::CPAN
{
return( $charset );
}
$self->_load_class( 'Encode' ) || return( $self->pass_error );
unless( defined( $BOM2ENC ) && scalar( %$BOM2ENC ) )
{
# Credits: Matthew Lawrence (File::BOM)
our $BOM2ENC = +{
map{ Encode::encode( $_, "\x{feff}" ) => $_ } qw(
UTF-8
UTF-16BE
UTF-16LE
UTF-32BE
UTF-32LE
)
};
our $ENC2BOM = +{
reverse( %$BOM2ENC ),
map{ $_ => Encode::encode( $_, "\x{feff}" ) } qw(
UCS-2
iso-10646-1
utf8
)
};
my @boms = sort{ length( $b ) <=> length( $a ) } keys( %$BOM2ENC );
our $BOM_MAX_LENGTH = length( $boms[0] );
{
local $" = '|';
our $BOM_RE = qr/@boms/;
}
}
# time to start guessing
# If called from decoded_content, kind of pointless to call decoded_content again
lib/HTTP/Promise/Entity.pm view on Meta::CPAN
return( '' ) if( !$bytes );
$cref = \$buff;
}
# Is there a Byte Order Mark?
if( $$cref =~ /^($BOM_RE)/ )
{
my $bom = $1;
return( $BOM2ENC->{ $bom } );
}
# Unicode BOM
return( 'UTF-8' ) if( $$cref =~ /^\xEF\xBB\xBF/ );
return( 'UTF-32LE' ) if( $$cref =~ /^\xFF\xFE\x00\x00/ );
return( 'UTF-32BE' ) if( $$cref =~ /^\x00\x00\xFE\xFF/ );
return( 'UTF-16LE' ) if( $$cref =~ /^\xFF\xFE/ );
return( 'UTF-16BE' ) if( $$cref =~ /^\xFE\xFF/ );
HTTP-PublicKeyPins
view release on metacpan or search on metacpan
t/certs/dsa.pem view on Meta::CPAN
ENrIZk98f+ouGgMJfvydlzzJeOhxXqrseK/e2mHFdtQ6nvI+M3AHp7FMQqk4x1dy
useKMWX8d5KsUxn0WrUCmguYTQR08zS5Y9620bqHhyolKOQC/cOz/jODe488eHFq
xRQ4I1XZTuq3AvwDu2BpJSCSIiP/2ESjmyS36iRJ54MTifY52WO2AvSpPEwLJOXT
0XEJEj6G0Xb9EiTlPn3T2CgDwdZVH1Z1iOA7c9EfjgoUfZtq1nCIZirDbDV1gmux
8nXLCov8H8J3PINlQR/ANZpjPvg75iiu4EzTczi/m2W9l7Doof+gEGVOLo5vbVJF
39mkSML3hZqjUDBOMB0GA1UdDgQWBBSNfxR0ZfkpP9aNQVY1H0JgVxrqvDAfBgNV
HSMEGDAWgBSNfxR0ZfkpP9aNQVY1H0JgVxrqvDAMBgNVHRMEBTADAQH/MAsGCWCG
SAFlAwQDAgNIADBFAiA35H431lpZJIt+3y2KsxDvn/Yxyq16fCaLX0rdiXA4igIh
ALVfEbSGkVc4mpb76IAnqdTR02TfMjSiwH8dIBK4eNEE
-----END CERTIFICATE-----
HTTP-StructuredFieldValues
view release on metacpan or search on metacpan
t/generated/display-string.t view on Meta::CPAN
eval { decode_item($input); };
ok($@, $test_name) or diag("Expected failure but got success");
}
# Test 19: BOM in display string
subtest "BOM in display string" => sub {
my $test_name = "BOM in display string";
my $input = "%\"BOM: %ef%bb%bf\"";
my $expected = { _type => 'displaystring', value => 'BOM: ' };
my $canonical = $input;
my $result = eval { decode_item($input); };
if ($@) {
( run in 2.722 seconds using v1.01-cache-2.11-cpan-c966e8aa7e8 )