You have data items ending with  etc but your narrative specifies "beginning with TAG1 *and* ending with TAG2" (and your code -- very slightly modifed with extra "say" and "use" statements -- at a quick glance seems to [more-or-less] support that narrative).

#!/usr/local/bin/perl
#use strict;
use warnings;
use 5.016;

# 1071296

while (<DATA>) {
# This section works OK.
    say "Positive lookaround first: ";
    if (/(?<=TAG1)(.*)(?=TAG2).*?/x) {
        print $1, "\n";
    }

   if (/^(?<!TAGS)(.*?)(?=TAG2).*$/x ) {
       say "\t Negative lookaround:";
       print $1, "\n";
   }
}

# Data now matches narrative; last item, stet, as out-of-spec test

__DATA__
TAG1 text one TAG2
TAG1 text two TAG2
TAG1 text three  TAG2
TAGS text four TAG2
TAG1 text five TAGT
[download]

Positive lookaround first:
 text one
         Negative lookaround:
TAG1 text one
Positive lookaround first:
 text two
         Negative lookaround:
TAG1 text two
Positive lookaround first:
 text three
         Negative lookaround:
TAG1 text three
Positive lookaround first:
         Negative lookaround:
TAGS text four
Positive lookaround first:
[download]

Updated to correct output shown. /me cut'n'pasted the wrong run, lacking tabs for ease of scanning.

Why are you using lookarounds at all?

m{^ starttag (.+?) enddag }xsm

Why? Because negative lookbehind is satisfied at any position except immediately after the given subpattern. Thus your (.*?) is free to match at the very beginning. Using a lookahead may accomplish what you had in mind (if $1 must contain the start tag).

   if (/^(?!TAGS)(.*?)TAG2/x ) {
      ...
[download]

[From the OP:]
if (/^(?<!TAGS)(.*?)(?=TAG2).*$/x ) {
    print $1, "\n";
}


Looked at another way,  ^(?<!TAGS) asserts that one wants a string that does not have certain characters before the start of the string. In the absence of the  /m regex modifier, this assertion can never fail!

With  /m active (allowing  ^ to also match after an embedded newline sequence), an assertion of this sort might be written that could actually fail, but then it would be an assertion about the end of the preceding line, and not about the start of the current line.

Just try this below code

#! /usr/bin/perl

use strict;
use warnings;

while (<DATA>) {
        chomp;
        if(/^TAG\d{1}.*TAG\d{1}.*/) {
                print ">>>$_<<\n";
        }
}

__DATA__
TAG1 text one TAG2 etc
TAG1 text two TAG2 etc
TAG1 text three  TAG2 etc
TAGS text four TAG2 etc
TAG1 text five TAGT etc
TAGZ text four TAGX etc
[download]

OK. Leslie. Your code works. But what I want is to make "negative look behind" work with this example. It's just to satisfy my knowledge...

>perl -wMstrict -le
"for ('TAG1 text one TAG2 etc',
      'TAGS text ess TAG2 etc',
      'TAG1 text two TAG2 etc',
   ) {
   print qq{'$_'} if m{ \A .... (?<! TAGS) .* TAG \d }xms;
   }
"
'TAG1 text one TAG2 etc'
'TAG1 text two TAG2 etc'
[download]

"The question is more a technical one: I am re-readning (camel book), Regexp chapter. And I really want to know how to use this negative look behind."

"perlre - Perl regular expressions" has the basic information. Look for Look-Around Assertions under "Extended Patterns".

Possibly of more use if you are learning, try "perlretut - Perl regular expressions tutorial". There's a whole section on "Looking ahead and looking behind".

You can also use Super Search which will provide copious examples of usage.

-- Ken