SQL check if group is continuous when ordered and return broken groups

WITH CTE AS (
SELECT 
  ID
  ,NNO
  ,DIDX
  ,SIDX
  ,LAG(NNO) OVER (ORDER BY DIDX, SIDX) as previousNNO
  ,LEAD(NNO) OVER (ORDER BY DIDX, SIDX) as nextNNO 
FROM Test
) 
SELECT 
 previousNNO as BrokenGroup
FROM CTE
WHERE previousNNO=nextNNO 
AND NNO<>previousNNO 

I used a CTE and WINDOW functions to also keep track of the previous and next group (NNO) for each row. A broken group will be one that has a different current group while the previous and next are the same. From your example with ID 24.

ID          NNO                     DIDX        SIDX
----------- -----------             ----------- -----------
...
12          85  < previous group    7906        0
24          666 < current group     7906        120       <<<<<<<<<<<<<<<<<<<
13          85  < next group        7907        0
...

I'm assuming that any consecutive range of DIDX should only have one NNO. As such there will be no two valid groups that abut each other.

This should help identify the offenders:

with data as (
    select NNO, DIDX, dense_rank() over (order by DIDX) as rn
    from Test
)
select min(DIDX) as range_start, max(DIDX) as range_end
from data
group by DIDX - rn
having count(distinct NNO) > 1;

Getting the actual rows:

with data as (
    select ID, NNO, DIDX, dense_rank() over (order by DIDX) as rn
    from Test
), groups as (
    select DIDX - rn as grp, min(DIDX) as range_start, max(DIDX) as range_end
    from data        
    group by DIDX - rn
    having count(distinct NNO) > 1
), data2 as (
    select *, lead(NNO) over (partition by grp order by DIDX) as next_NNO 
    from Test t inner join groups g
        on t.DIDX between g.range_start and g.range_end
)
select * from data2 where NNO <> next_NNO;

If you're looking for a test to run prior to inserting a row:

with data as (
    select NNO, DIDX, row_number() over (order by DIDX) as rn
    from Test
)
select case when min(DIDX) is not null then 'Fail' else 'Pass' end as InsertTest
from data
group by DIDX - rn
having @proposed_DIDX between min(DIDX) and max(DIDX)
    and @proposed_NNO <> min(NNO);

OK, so inspired by given answers (which I voted up for helping), I came with this code that seems to provide the desired result. I'm not sure though, if it's the cleanest and shortest possible way.

;WITH CTE AS (
    SELECT NNO, 
           DMIN, 
           DMAX,
           SMIN,
           SMAX,
           LEAD(DMIN) OVER (ORDER BY DMIN, SMIN) as nextDMIN,
           LAG(DMAX) OVER (ORDER BY DMIN, SMIN) as prevDMAX,
           LAG(SMAX) OVER (ORDER BY DMIN, SMIN) as prevSMAX,
           LEAD(SMIN) OVER (ORDER BY DMIN, SMIN) as nextSMIN,
           CNT
    FROM (
        SELECT NNO, 
               MIN(DIDX) as DMIN, 
               MAX(DIDX) as DMAX, 
               MIN(SIDX) as SMIN, 
               MAX(SIDX) as SMAX,
               COUNT(NNO) as CNT
        FROM Test
        GROUP BY NNO
        ) as SRC
    )

SELECT * 
FROM CTE
WHERE ((prevDMAX > DMIN OR (prevDMAX = DMIN AND prevSMAX > SMIN)) OR 
       (nextDMIN < DMAX OR (nextDMIN = DMAX AND nextSMIN < SMAX)))
      AND CNT > 1

Perhaps I should give a little explanation. The code finds MIN and MAX border values for each parameter SMIN and DMIN and then find those values for previous and next rows. We also COUNT number of rows in a group.

The conditions in brackets basicaly say, that no record of other group can be in DMIN and DMAX range, and if it's on the borders of the range, then it has to be outside SMIN or SMAX. Finally, a broken group must have more then 1 row; otherwise the query would return not only offendee group, but also first offender.

I should say, that this code has a little flaw and that is a case when there would be an offender with more than one row intact in between ofendee group rows. I should be able to tackle this in post processing, where I have to shuffle rows to achieve intact groups.