LabelKey:           viper.GetString(constants.RepairLabelKey),
		LabelValue:         viper.GetString(constants.RepairLabelValue),
		NodeName:           viper.GetString(constants.RepairNodeName),
		SidecarAnnotation:  viper.GetString(constants.RepairSidecarAnnotation),
		InitContainerName:  viper.GetString(constants.RepairInitContainerName),
		InitTerminationMsg: viper.GetString(constants.RepairInitTerminationMsg),

		overlay = append(overlay, o)
	}
	baseYAML, err := f.GetString()
	if err != nil {
		return 0
	}
	defaultNamespace, err := f.GetString()
	if err != nil {
		return 0
	}

	_, _ = patch.YAMLManifestPatch(baseYAML, defaultNamespace, overlay)
	return 1
}

func FuzzGalleyDiag(data []byte) int {
	f := fuzz.NewConsumer(data)

	code, err := f.GetString()
	if err != nil {
		return 0
	}

    writer.close();

    assertTrue(sink.wasStreamClosed());
    assertEquals(STRING, sink.getString());
  }

  public void testWrite_string() throws IOException {
    assertEquals("", sink.getString());
    sink.write(STRING);

    assertTrue(sink.wasStreamOpened() && sink.wasStreamClosed());
    assertEquals(STRING, sink.getString());
  }

  public void testWriteFrom_reader() throws IOException {

                        performanceResults.setJvm(testExecutions.getString(10));
                        performanceResults.setVcsBranch(mapVcsBranch(channelPatterns.get(0), testExecutions.getString(11).trim()));
                        performanceResults.setVcsCommits(ResultsStoreHelper.split(testExecutions.getString(12)));

                        String testClass = experimentTimes.getString(++resultIdx)
                        String testName = experimentTimes.getString(++resultIdx)
                        String testProject = experimentTimes.getString(++resultIdx)
                        OperatingSystem os = OperatingSystem.valueOf(experimentTimes.getString(++resultIdx))
                        long avgDuration = experimentTimes.getLong(++resultIdx)

	f := fuzz.NewConsumer(data)
	filter, err := f.GetString()
	if err != nil {
		return 0
	}
	number, err := f.GetInt()
	if err != nil {
		return 0
	}
	maxKeys := number % 100
	keys := make([]string, 0, maxKeys)
	for i := 0; i < maxKeys; i++ {
		key, err := f.GetString()
		if err != nil {
			return 0
		}
		keys = append(keys, key)
	}
	value, err := f.GetString()
	if err != nil {
		return 0
	}

                    return "REALPATH for ${buffer.getString()}"
                case SftpConstants.SSH_FXP_STAT:
                    return "STAT for ${buffer.getString()}"
                case SftpConstants.SSH_FXP_OPENDIR:
                    return "OPENDIR for ${buffer.getString()}"
                case SftpConstants.SSH_FXP_READDIR:
                    return "READDIR for ${buffer.getString()}"
                case SftpConstants.SSH_FXP_MKDIR:

		}
		s.locationIDX = nil
	}

	p.DropFrames, err = getString(p.stringTable, &p.dropFramesX, err)
	p.KeepFrames, err = getString(p.stringTable, &p.keepFramesX, err)

	if pt := p.PeriodType; pt == nil {
		p.PeriodType = &ValueType{}
	}

	if pt := p.PeriodType; pt != nil {
		pt.Type, err = getString(p.stringTable, &pt.typeX, err)
		pt.Unit, err = getString(p.stringTable, &pt.unitX, err)
	}

	f := fuzz.NewConsumer(data)
	var sidecarTemplate map[string]string
	err := f.FuzzMap(&sidecarTemplate)
	if err != nil {
		return 0
	}
	valuesConfig, err := f.GetString()
	if err != nil {
		return 0
	}
	meshYaml, err := f.GetString()
	if err != nil {
		return 0
	}
	mc, err := mesh.ApplyMeshConfigDefaults(meshYaml)
	if err != nil {
		return 0
	}
	inData, err := f.GetBytes()
	if err != nil {

                    println "setStrings: " + ($.setStrings as List)
                  }
                }
              }
            }
        '''

        then:
        succeeds "print"

        and:
        output.contains "mapThings: [[a, b], [a]]"
        output.contains "setThings: [[Thing 'setThings.0.0']]"
        output.contains "setStrings: [[a], [b]]"
    }