if re.Match(ln) {
			return true
		}
	}
	return false
}

// doGrep looks for a regular expression in a buffer and fails if it
// is not found. The name argument is the name of the output we are
// searching, "output" or "error". The msg argument is logged on
// failure.
func (tg *testgoData) doGrep(match string, b *bytes.Buffer, name, msg string) {
	tg.t.Helper()
	if !tg.doGrepMatch(match, b) {

	docQueryString := ""
	if m.DocRef != "" {
		docQueryString = fmt.Sprintf("?ref=%s", m.DocRef)
	}
	result["documentationUrl"] = fmt.Sprintf("%s/%s/%s", url.ConfigAnalysis, strings.ToLower(m.Type.Code()), docQueryString)

	return result
}

func (m *Message) AnalysisMessageBase() *v1alpha1.AnalysisMessageBase {
	docQueryString := ""
	if m.DocRef != "" {
		docQueryString = fmt.Sprintf("?ref=%s", m.DocRef)
	}

			continue
		}
		deduped = append(deduped, m)
	}
	return deduped
}

// SetDocRef sets the doc URL reference tracker for the messages
func (ms *Messages) SetDocRef(docRef string) *Messages {
	for i := range *ms {
		(*ms)[i].DocRef = docRef
	}
	return ms
}

// FilterOutLowerThan only keeps messages at or above the specified output level
func (ms *Messages) FilterOutLowerThan(outputLevel Level) Messages {

// Double return value is just for testing.
//
//export GoStart
func GoStart(i, xdim, ydim, xstart, xend, ystart, yend C.int, a *C.int, n *C.int) (int, int) {
	c := make(chan bool, int(C.MYCONST))
	go func() {
		C.DoStep(xdim, ydim, xstart, xend, ystart, yend, a, n)
		c <- true
	}()
	chans[i] = c
	return int(i), int(i + 100)
}

//export GoWait
func GoWait(i C.int) {
	<-chans[i]
	chans[i] = nil

// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

extern void Step(int, int, int *, int *);
extern void DoStep(int, int, int, int, int, int, int *, int *);

// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

extern void Step(int, int, int *, int *);
extern void DoStep(int, int, int, int, int, int, int *, int *);

}

func TestMessageWithDocRef(t *testing.T) {
	g := NewWithT(t)
	mt := NewMessageType(Error, "IST0042", "Cheese type not found: %q")
	m := NewMessage(mt, nil, "Feta")
	m.DocRef = "test-ref"
	g.Expect(m.Unstructured(false)["documentationUrl"]).To(Equal(url.ConfigAnalysis + "/ist0042/?ref=test-ref"))
}

func TestMessage_JSON(t *testing.T) {
	g := NewWithT(t)

	GoStart(2, x, y, 0, x / 2, y / 2, y, a, n);
	GoStart(3, x, y, x / 2, x, y / 2, y, a, n);
	GoWait(0);
	GoWait(1);
	GoWait(2);
	GoWait(3);
}

// The actual computation.  This is called in parallel.
void
DoStep(int xdim, int ydim, int xstart, int xend, int ystart, int yend, int *a, int *n)
{
	int x, y, c, i, j;

	for(x = xstart; x < xend; x++) {
		for(y = ystart; y < yend; y++) {
			c = 0;
			for(i = -1; i <= 1; i++) {

// Double return value is just for testing.
//
//export GoStart
func GoStart(i, xdim, ydim, xstart, xend, ystart, yend C.int, a *C.int, n *C.int) (int, int) {
	c := make(chan bool, int(C.MYCONST))
	go func() {
		C.DoStep(xdim, ydim, xstart, xend, ystart, yend, a, n)
		c <- true
	}()
	chans[i] = c
	return int(i), int(i + 100)
}

//export GoWait
func GoWait(i C.int) {
	<-chans[i]
	chans[i] = nil

                    if (i != j && components.contains(asArray[j])) {
                        doDrop = true;
                        asArray[i] = null;
                        break;
                    }
                }
            }
        }
        if (doDrop) {
            specs = Arrays.stream(asArray).filter(Objects::nonNull).collect(toSet());
        }
        return specs;