text:
package com.github.jamesnetherton.lolcat4j.internal.commandline;

import java.util.ArrayList;
import java.util.List;

class OptionList {
    private final List<Option> options = new ArrayList<>();

    public void addToOptions(Option option) {
        options.add(option);
    }

    public Option findOption(String optionFlag) throws UnknownOptionException {
        for (Option option : options) {
            if (isValidMatch(option, optionFlag)) {
                return option;
            }
        }
        throw new UnknownOptionException("Unknown option: " + optionFlag);
    }

    public boolean containsOption(String optionFlag) {
        for (Option option : options) {
            if (isValidMatch(option, optionFlag)) {
                return true;
            }
        }
        return false;
    }

    public List<Option> getOptions() {
        return options;
    }

    private boolean isValidMatch(Option option, String optionFlag) {
        return option.getShortOption().equals(optionFlag) || option.getLongOption().equals(optionFlag) || option.getName().equals(optionFlag);
    }
}

redpajama_set_name: RedPajamaGithub


text:
package com.opengamma.engine.depgraph;

import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.opengamma.engine.value.ValueRequirement;
import com.opengamma.engine.value.ValueSpecification;

/**
 * Wraps another visitor to gather the return values of it.
 *
 * @param <T> return type of the visit methods
 */
public class ResolutionFailureGatherer<T> extends ResolutionFailureVisitor<T> {

  private final ResolutionFailureVisitor<T> _underlying;
  private final List<T> _results = new LinkedList<T>();

  public ResolutionFailureGatherer(final ResolutionFailureVisitor<T> underlying) {
    _underlying = underlying;
  }

  public ResolutionFailureVisitor<T> getUnderlying() {
    return _underlying;
  }

  public Collection<T> getResults() {
    return Collections.unmodifiableList(_results);
  }

  private synchronized T result(final T result) {
    _results.add(result);
    return result;
  }

  @Override
  protected T visitCouldNotResolve(final ValueRequirement valueRequirement) {
    return result(getUnderlying().visitCouldNotResolve(valueRequirement));
  }

  @Override
  protected T visitNoFunctions(final ValueRequirement valueRequirement) {
    return result(getUnderlying().visitNoFunctions(valueRequirement));
  }

  @Override
  protected T visitRecursiveRequirement(final ValueRequirement valueRequirement) {
    return result(getUnderlying().visitRecursiveRequirement(valueRequirement));
  }

  @Override
  protected T visitUnsatisfied(final ValueRequirement valueRequirement) {
    return result(getUnderlying().visitUnsatisfied(valueRequirement));
  }

  @Override
  protected T visitMarketDataMissing(final ValueRequirement valueRequirement) {
    return result(getUnderlying().visitMarketDataMissing(valueRequirement));
  }

  @Override
  protected T visitSuccessfulFunction(final ValueRequirement valueRequirement, final String function, final ValueSpecification desiredOutput,
      final Map<ValueSpecification, ValueRequirement> satisfied) {
    return result(getUnderlying().visitSuccessfulFunction(valueRequirement, function, desiredOutput, satisfied));
  }

  @Override
  protected T visitFailedFunction(final ValueRequirement valueRequirement, final String function, final ValueSpecification desiredOutput,
      final Map<ValueSpecification, ValueRequirement> satisfied, final Set<ResolutionFailure> unsatisfied) {
    return result(getUnderlying().visitFailedFunction(valueRequirement, function, desiredOutput, satisfied, unsatisfied));
  }

  @Override
  protected T visitFailedFunction(final ValueRequirement valueRequirement, final String function, final ValueSpecification desiredOutput,
      final Map<ValueSpecification, ValueRequirement> satisfied, final Set<ResolutionFailure> unsatisfied, final Set<ResolutionFailure> unsatisfiedAdditional) {
    return result(getUnderlying().visitFailedFunction(valueRequirement, function, desiredOutput, satisfied, unsatisfied, unsatisfiedAdditional));
  }

  @Override
  protected T visitFunction(final ValueRequirement valueRequirement, final String function, final ValueSpecification desiredOutput,
      final Map<ValueSpecification, ValueRequirement> satisfied, final Set<ResolutionFailure> unsatisfied, final Set<ResolutionFailure> unsatisfiedAdditional) {
    return result(getUnderlying().visitFunction(valueRequirement, function, desiredOutput, satisfied, unsatisfied, unsatisfiedAdditional));
  }

  @Override
  protected T visitGetAdditionalRequirementsFailed(final ValueRequirement valueRequirement, final String function, final ValueSpecification desiredOutput,
      final Map<ValueSpecification, ValueRequirement> requirements) {
    return result(getUnderlying().visitGetAdditionalRequirementsFailed(valueRequirement, function, desiredOutput, requirements));
  }

  @Override
  protected T visitGetResultsFailed(final ValueRequirement valueRequirement, final String function, final ValueSpecification desiredOutput,
      final Map<ValueSpecification, ValueRequirement> requirements) {
    return result(getUnderlying().visitGetResultsFailed(valueRequirement, function, desiredOutput, requirements));
  }

  @Override
  protected T visitGetRequirementsFailed(final ValueRequirement valueRequirement, final String function, final ValueSpecification desiredOutput) {
    return result(getUnderlying().visitGetRequirementsFailed(valueRequirement, function, desiredOutput));
  }

  @Override
  protected T visitLateResolutionFailure(final ValueRequirement valueRequirement, final String function, final ValueSpecification desiredOutput,
      final Map<ValueSpecification, ValueRequirement> requirements) {
    return result(getUnderlying().visitLateResolutionFailure(valueRequirement, function, desiredOutput, requirements));
  }

  @Override
  protected T visitBlacklistSuppressed(final ValueRequirement valueRequirement, final String function, final ValueSpecification desiredOutput,
      final Map<ValueSpecification, ValueRequirement> requirements) {
    return result(getUnderlying().visitBlacklistSuppressed(valueRequirement, function, desiredOutput, requirements));
  }

}


text:
class Middleman::Extensions::MinifyCss < ::Middleman::Extension
  option :compressor, nil, 'Set the CSS compressor to use.'
  option :inline, false, 'Whether to minify CSS inline within HTML files'
  option :ignore, [], 'Patterns to avoid minifying'

  def initialize(app, options_hash={}, &block)
    super

    app.config.define_setting :css_compressor, nil, 'Set the CSS compressor to use. Deprecated in favor of the :compressor option when activating :minify_css'
  end

  def after_configuration
    chosen_compressor = app.config[:css_compressor] || options[:compressor] || SassCompressor

    # Setup Rack middleware to minify CSS
    app.use Rack, compressor: chosen_compressor,
                  ignore: Array(options[:ignore]) + [/\.min\./],
                  inline: options[:inline]
  end

  class SassCompressor
    def self.compress(style, options={})
      root_node = ::Sass::SCSS::CssParser.new(style, 'middleman-css-input', 1).parse
      root_node.options = options.merge(style: :compressed)
      root_node.render.strip
    end
  end

  # Rack middleware to look for CSS and compress it
  class Rack
    INLINE_CSS_REGEX = /(<style[^>]*>\s*(?:\/\*<!\[CDATA\[\*\/\n)?)(.*?)((?:(?:\n\s*)?\/\*\]\]>\*\/)?\s*<\/style>)/m

    # Init
    # @param [Class] app
    # @param [Hash] options
    def initialize(app, options={})
      @app = app
      @compressor = options[:compressor]
      @ignore = options[:ignore]
      @inline = options[:inline]
    end

    # Rack interface
    # @param [Rack::Environmemt] env
    # @return [Array]
    def call(env)
      status, headers, response = @app.call(env)

      if inline_html_content?(env['PATH_INFO'])
        minified = ::Middleman::Util.extract_response_text(response)
        minified.gsub!(INLINE_CSS_REGEX) do
          $1 << @compressor.compress($2) << $3
        end

        headers['Content-Length'] = ::Rack::Utils.bytesize(minified).to_s
        response = [minified]
      elsif standalone_css_content?(env['PATH_INFO'])
        minified_css = @compressor.compress(::Middleman::Util.extract_response_text(response))

        headers['Content-Length'] = ::Rack::Utils.bytesize(minified_css).to_s
        response = [minified_css]
      end

      [status, headers, response]
    end

    private

    def inline_html_content?(path)
      (path.end_with?('.html') || path.end_with?('.php')) && @inline
    end

    def standalone_css_content?(path)
      path.end_with?('.css') && @ignore.none? { |ignore| Middleman::Util.path_match(ignore, path) }
    end
  end
end


text:
package io.buoyant

import com.twitter.finagle._
import io.buoyant.namer.RichActivity
import io.buoyant.test.FunSuite

class HostPortTest extends FunSuite {

  def lookup(path: Path) =
    await(Namer.global.lookup(path).toFuture)

  test("io.buoyant.hostportPfx matches IP:PORT") {
    val path = Path.read("/$/io.buoyant.hostportPfx/ia/127.1:8080/etc")
    assert(lookup(path) == NameTree.Leaf(Name.Path(Path.Utf8("ia", "127.1", "8080", "etc"))))
  }

  test("io.buoyant.hostportPfx matches HOST:PORT") {
    val path = Path.read("/$/io.buoyant.hostportPfx/ia/google.com:8180/etc")
    assert(lookup(path) == NameTree.Leaf(Name.Path(Path.Utf8("ia", "google.com", "8180", "etc"))))
  }

  test("io.buoyant.hostportPfx does not match HOST:PORT:ETC") {
    val path = Path.read("/$/io.buoyant.hostportPfx/ia/google.com:8180:abcdef/etc")
    assert(lookup(path) == NameTree.Neg)
  }

  test("io.buoyant.porthostPfx matches IP:PORT") {
    val path = Path.read("/$/io.buoyant.porthostPfx/ia/127.1:8080/etc")
    assert(lookup(path) == NameTree.Leaf(Name.Path(Path.Utf8("ia", "8080", "127.1", "etc"))))
  }

  test("io.buoyant.hostportPfx matches HOST:PORT with string port") {
    val path = Path.read("/$/io.buoyant.hostportPfx/ia/google.com:http/etc")
    assert(lookup(path) == NameTree.Leaf(Name.Path(Path.Utf8("ia", "google.com", "http", "etc"))))
  }

  test("io.buoyant.hostportPfx matches IP:PORT with string port") {
    val path = Path.read("/$/io.buoyant.hostportPfx/ia/127.1:http/etc")
    assert(lookup(path) == NameTree.Leaf(Name.Path(Path.Utf8("ia", "127.1", "http", "etc"))))
  }

  test("io.buoyant.hostportPfx does not match HOST:PORT:ETC with string port") {
    val path = Path.read("/$/io.buoyant.hostportPfx/ia/google.com:http:abcdef/etc")
    assert(lookup(path) == NameTree.Neg)
  }

  test("io.buoyant.porthostPfx matches IP:PORT with string port") {
    val path = Path.read("/$/io.buoyant.porthostPfx/ia/127.1:http/etc")
    assert(lookup(path) == NameTree.Leaf(Name.Path(Path.Utf8("ia", "http", "127.1", "etc"))))
  }
}


text:
package org.foxlabs.etk.function.base;

import org.foxlabs.etk.Environment;
import org.foxlabs.etk.annotation.FxNames;
import org.foxlabs.etk.function.Function;

@FxNames({"TOSTRING", "TOSTR", "STRING", "STR"})
public class ToString extends Function {

    public ToString(String name, String namespace) {
        super(name, namespace, String.class, Object.class);
    }

    public boolean isDetermined() {
        return true;
    }

    public Object evaluate(Environment context, Object... arguments) {
        return arguments[0] == null ? "" : arguments[0].toString();
    }

}


text:
include(Platform/Apple-GNU)
__apple_compiler_gnu(OBJC)
cmake_gnu_set_sysroot_flag(OBJC)
cmake_gnu_set_osx_deployment_target_flag(OBJC)


text:
BalloonManager = Periodic.new(BalloonManager_UpdateRate, BalloonManager_Control, 4)
ShieldManager = Periodic.new(ShieldManager_UpdateRate, ShieldManager_Control, 3)
MissileMain = Periodic.new(Missile_UpdateRate, MissileMain_Update, 2)
AltitudeControl = Periodic.new(AltitudeControl_UpdateRate, Altitude_Control, 1)
GunshipAI = Periodic.new(AI_UpdateRate, GunshipAI_Update)

SelectHeadingImpl(AllDoF)
SelectPositionImpl(AllDoF)
SelectAltitudeImpl(AllDoF)
SelectPitchImpl(AllDoF)
SelectRollImpl(AllDoF)

function Update(I) -- luacheck: ignore 131
   C = Commons.new(I)
   FirstRun(I)
   if not C:IsDocked() then
      AltitudeControl:Tick(I)

      if ActivateWhen[C:MovementMode()] then
         GunshipAI:Tick(I)

         -- Suppress default AI
         I:TellAiThatWeAreTakingControl()
      else
         GunshipAI_Reset()
         V.Reset()
      end

      if BalloonManager_Kill() then V.Reset() end

      Altitude_Apply(I, DodgeAltitudeOffset)
      AllDoF.Update(I)

      MissileMain:Tick(I)
   else
      AllDoF.Disable(I)
   end

   ShieldManager:Tick(I)
   BalloonManager:Tick(I)
end


text:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html
  PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

        <title>ScalaTest Suite com.example.qa.FixPricePaymentTypeTest Results</title>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
        <meta http-equiv="Expires" content="-1"/>
        <meta http-equiv="Pragma" content="no-cache"/>
        <link href="css/styles.css" rel="stylesheet"/>

FixPricePaymentTypeTest

          Tests: total 4, succeeded 4, failed 0, canceled 0, ignored 0, pending 0

Campaign should be filtered by price if publisher.clientId = vm (31 milliseconds)

Campaign should not be filtered by price with if exchange.ignorePubCpm = true -> publisher.clientId = vm (4 seconds, 842 milliseconds)

Campaign should not be filtered by price with if exchange.ignorePubCpm = true -> publisher.clientId != vm (4 seconds, 922 milliseconds)

Query param 'bid_floor' should be ignored (989 milliseconds)

            Suite ID
            com.example.qa.FixPricePaymentTypeTest

            Class name
            com.example.qa.FixPricePaymentTypeTest

            Total duration

              16 seconds, 580 milliseconds

(Open FixPricePaymentTypeTest in new tab)


text:
package ocp.example2.fixed;

import java.util.ArrayList;
import java.util.List;

public class SizeFilterSpecification extends ProductFilterSpecification {

    private ProductSize productSize;

    public SizeFilterSpecification(ProductSize productSize) {
        this.productSize = productSize;
    }

    @Override
    protected List<Product> applyFilter(List<Product> products) {
        List<Product> productList = new ArrayList<Product>();

        for (Product product : products) {
            if (product.getSize() == productSize.getSize()) {
                productList.add(product);
            }
        }

        return productList;
    }
}


text:
package apiserver

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/GoogleCloudPlatform/kubernetes/pkg/probe"
	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
)

type fakeHttpGet struct {
	err  error
	resp *http.Response
	url  string
}

func (f *fakeHttpGet) Get(url string) (*http.Response, error) {
	f.url = url
	return f.resp, f.err
}

func makeFake(data string, statusCode int, err error) *fakeHttpGet {
	return &fakeHttpGet{
		err: err,
		resp: &http.Response{
			Body:       ioutil.NopCloser(bytes.NewBufferString(data)),
			StatusCode: statusCode,
		},
	}
}

func TestValidate(t *testing.T) {
	tests := []struct {
		err            error
		data           string
		expectedStatus probe.Result
		code           int
		expectErr      bool
	}{
		{fmt.Errorf("test error"), "", probe.Unknown, 500 /*ignored*/, true},
		{nil, "foo", probe.Success, 200, false},
		{nil, "foo", probe.Failure, 500, true},
	}

	s := Server{Addr: "foo.com", Port: 8080, Path: "/healthz"}

	for _, test := range tests {
		fake := makeFake(test.data, test.code, test.err)
		status, data, err := s.check(fake)
		expect := fmt.Sprintf("http://%s:%d/healthz", s.Addr, s.Port)
		if fake.url != expect {
			t.Errorf("expected %s, got %s", expect, fake.url)
		}
		if test.expectErr && err == nil {
			t.Errorf("unexpected non-error")
		}
		if !test.expectErr && err != nil {
			t.Errorf("unexpected error: %v", err)
		}
		if data != test.data {
			t.Errorf("expected empty string, got %s", status)
		}
		if status != test.expectedStatus {
			t.Errorf("expected %s, got %s", test.expectedStatus.String(), status.String())
		}
	}
}

func TestValidator(t *testing.T) {
	fake := makeFake("foo", 200, nil)
	validator, err := makeTestValidator(map[string]string{
		"foo": "foo.com:80",
		"bar": "bar.com:8080",
	}, fake)
	if err != nil {
		t.Errorf("unexpected error: %v", err)
	}

	testServer := httptest.NewServer(validator)
	defer testServer.Close()

	resp, err := http.Get(testServer.URL + "/validatez")

	if err != nil {
		t.Errorf("unexpected error: %v", err)
	}
	if resp.StatusCode != http.StatusOK {
		t.Errorf("unexpected response: %v", resp.StatusCode)
	}
	defer resp.Body.Close()
	data, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		t.Errorf("unexpected error: %v", err)
	}
	status := []ServerStatus{}
	err = json.Unmarshal(data, &status)
	if err != nil {
		t.Errorf("unexpected error: %v", err)
	}
	components := util.StringSet{}
	for _, s := range status {
		components.Insert(s.Component)
	}
	if len(status) != 2 || !components.Has("foo") || !components.Has("bar") {
		t.Errorf("unexpected status: %#v", status)
	}
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
     android:shape="rectangle">
     <solid android:color="@color/baseline_neutral_50"/>
     <corners android:radius="@dimen/back_to_top_bubble_corner_radius" />
</shape>


text:
define('zfegg/kendo/restful-data-source', ['kendo'], function (kendo) {

    var MIME_JSON = 'application/json';

    var defaultsSchema = {
        data: function (d) {
            if (d._embedded) {  //GET
                if (this.dataKey) {
                    return d._embedded[this.dataKey];
                } else {
                    for (var i in d._embedded) {
                        return d._embedded[i];
                    }
                }
            } else { //POST && PUT
                return d;
            }
        },
        dataKey: null,
        total: 'total_items'
    };

    var DataSource = kendo.data.DataSource.extend({
        init: function (options) {
            var self = this;
            var primary = (options.schema.model && options.schema.model.id) || 'id';
            var extendTransport1 = {read: {url: options.url}, create: {url: options.url}};
            var extendTransport2 = {
                read: {
                    url: null,
                    type: "GET",
                    dataType: "json"
                },
                create: {
                    url:  null,
                    type: "POST",
                    dataType: "json",
                    contentType: MIME_JSON
                },
                update: {
                    url: function (e) {
                        return options.url + "/" + e[primary];
                    },
                    type: "PATCH",
                    dataType: "json",
                    contentType: MIME_JSON
                },
                destroy: {
                    url: function (e) {
                        return options.url + "/" + e[primary];
                    },
                    type: "DELETE",
                    dataType: "json",
                    contentType: MIME_JSON
                },
                parameterMap: function (options, operation) {
                    if (operation == 'update') {
                        var pristine = self._pristineForModel(self.get(options[primary]));
                        var patchData = $.extend({}, options); //clone data

                        for (var i in patchData) {
                            var item = patchData[i];
                            if (typeof item == 'object' || typeof item == 'function') {
                                continue;
                            }

                            if (item == pristine[i]) {
                                delete patchData[i];
                            }
                        }

                        delete patchData._links;

                        return JSON.stringify(patchData);
                    }
                    if (operation == 'create' || operation == 'destroy') {
                        return JSON.stringify(options);
                    }

                    return options;
                }
            };

            options.schema = $.extend(defaultsSchema, options.schema || {});
            options.transport = $.extend(extendTransport1, options.transport || {});
            options.transport = $.extend(true, extendTransport2, options.transport);

            kendo.data.DataSource.fn.init.call(this, options);
        },
        promise: function () {
            if (!this._promiseCaller) {
                this._promiseCaller = this.fetch();
            }

            return this._promiseCaller;
        },
        _promiseCaller: null
    });

    DataSource.gridErrorStatusListener = function (e, kGrid) {
        if (e.xhr.status == 422 && e.xhr.responseJSON && e.xhr.responseJSON.validation_messages) {
            var v = kGrid.editable.element.data('kendoValidator');
            var messages = e.xhr.responseJSON.validation_messages;

            for (var name in messages) {
                var input = v.element.find('[name='+name+']');

                for (var errorKey in messages[name]) {
                    var msg = messages[name][errorKey];
                    $(kendo.template(v.options.errorTemplate)({message: msg})).insertAfter(input);
                    input.focus();
                }
            }
        }
    };

    return DataSource;
});


text:
<?php

require_once('DbHandler.php');
require_once('CRMDefaults.php');
require_once('LanguageHandler.php');
$lh = \creamy\LanguageHandler::getInstance();

// check required fields
$validated = 1;
if (!isset($_POST["userid"])) {
	$validated = 0;
}
if (!isset($_POST["old_password"])) {
	$validated = 0;
}
if (!isset($_POST["new_password_1"])) {
	$validated = 0;
}
if (!isset($_POST["new_password_2"])) {
	$validated = 0;
}

if ($validated == 1) {
	$db = new \creamy\DbHandler();

	// check password
	$userid = $_POST["userid"];
	$oldpassword = $_POST["old_password"];
	$password1 = $_POST["new_password_1"];
	$password2 = $_POST["new_password_2"];
	if ($password1 !== $password2) {
		ob_clean();
		$lh->translateText("passwords_dont_match");
	} else { // everything's ok, now try to set the new password.
		$result = $db->changePassword($userid, $oldpassword, $password1, $password2);
		if ($result === true) { ob_clean(); print CRM_DEFAULT_SUCCESS_RESPONSE; }
		else { ob_clean(); $lh->translateText("unable_change_password"); }
	}
} else { ob_clean(); $lh->translateText("some_fields_missing"); }
?>


text:
	<?php include ('headeradmin.php');?>

SELAMAT DATANG
<?php echo $this->session->userdata('namaadmin'); ?>


text:
    <meta http-equiv="Content-Type" content="text/html; charset=Windows-1252" />
    <meta name="vs_targetSchema" content="http://schemas.microsoft.com/intellisense/ie5" />
    <title>Field.Index.NOT_ANALYZED Field</title>
    <xml>
    </xml>
    <link rel="stylesheet" type="text/css" href="MSDN.css" />

            Apache Lucene.Net 2.4.0 Class Library API

Field.Index.NOT_ANALYZED Field

Index the field's value without using an Analyzer, so it can be searched. As no analyzer is used the value will be stored as a single term. This is useful for unique Ids like product numbers.

public static readonly Index NOT_ANALYZED;

See Also

        Field.Index Class | Lucene.Net.Documents Namespace

      <object type="application/x-oleobject" classid="clsid:1e2a7bd0-dab9-11d0-b93a-00c04fc99f9e" viewastext="true" style="display: none;">
        <param name="Keyword" value="NOT_ANALYZED field">
        </param>
        <param name="Keyword" value="NOT_ANALYZED field, Field.Index class">
        </param>
        <param name="Keyword" value="Field.Index.NOT_ANALYZED field">
        </param>
      </object>

Generated from assembly Lucene.Net [2.4.0.2]


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Labs.MvcHater.Endpoints;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;

namespace Labs.MvcHater
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddRouting();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseRouter(router =>
            {
                router.MapGet("api/woo", async (request, response, routeData) => await response.WriteAsync(new WooEndpoint().Get()));
            });
        }
    }
}


text:
package rfc

import (
	"github.com/zmap/zcrypto/x509"
	"github.com/zmap/zlint/v3/lint"
	"github.com/zmap/zlint/v3/util"
)

type noticeRefPres struct{}

/********************************************************************
The user notice has two optional fields: the noticeRef field and the
explicitText field. Conforming CAs SHOULD NOT use the noticeRef
option.
********************************************************************/

func init() {
	lint.RegisterLint(&lint.Lint{
		Name:          "w_ext_cert_policy_contains_noticeref",
		Description:   "Compliant certificates SHOULD NOT use the noticeRef option",
		Citation:      "RFC 5280: 4.2.1.4",
		Source:        lint.RFC5280,
		EffectiveDate: util.RFC5280Date,
		Lint:          NewNoticeRefPres,
	})
}

func NewNoticeRefPres() lint.LintInterface {
	return &noticeRefPres{}
}

func (l *noticeRefPres) CheckApplies(c *x509.Certificate) bool {
	return util.IsExtInCert(c, util.CertPolicyOID)
}

func (l *noticeRefPres) Execute(c *x509.Certificate) *lint.LintResult {
	for _, firstLvl := range c.NoticeRefNumbers {
		for _, number := range firstLvl {
			if number != nil {
				return &lint.LintResult{Status: lint.Warn}
			}
		}
	}
	for _, firstLvl := range c.NoticeRefOrgnization {
		for _, org := range firstLvl {
			if len(org.Bytes) != 0 {
				return &lint.LintResult{Status: lint.Warn}
			}
		}
	}

	return &lint.LintResult{Status: lint.Pass}
}


text:
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Dynamic;
using System.Linq.Expressions;
using Microsoft.CSharp.RuntimeBinder.Semantics;

namespace Microsoft.CSharp.RuntimeBinder
{
    /// <summary>
    /// Represents a dynamic binary operation in C#, providing the binding semantics and the details about the operation.
    /// Instances of this class are generated by the C# compiler.
    /// </summary>
    internal sealed class CSharpBinaryOperationBinder : BinaryOperationBinder, ICSharpBinder
    {
        [ExcludeFromCodeCoverage]
        public string Name
        {
            get
            {
                Debug.Fail("Name should not be called for this binder");
                return null;
            }
        }

        public BindingFlag BindingFlags => 0;

        public Expr DispatchPayload(RuntimeBinder runtimeBinder, ArgumentObject[] arguments, LocalVariableSymbol[] locals)
            => runtimeBinder.BindBinaryOperation(this, arguments, locals);

        public void PopulateSymbolTableWithName(Type callingType, ArgumentObject[] arguments)
        {
            string name = Operation.GetCLROperatorName();
            Debug.Assert(name != null);
            SymbolTable.PopulateSymbolTableWithName(name, null, arguments[0].Type);
            SymbolTable.PopulateSymbolTableWithName(name, null, arguments[1].Type);
        }

        public bool IsBinderThatCanHaveRefReceiver => false;

        internal bool IsLogicalOperation => (_binopFlags & CSharpBinaryOperationFlags.LogicalOperation) != 0;

        private readonly CSharpBinaryOperationFlags _binopFlags;

        private readonly CSharpArgumentInfo[] _argumentInfo;

        CSharpArgumentInfo ICSharpBinder.GetArgumentInfo(int index) => _argumentInfo[index];

        private readonly RuntimeBinder _binder;

        //////////////////////////////////////////////////////////////////////

        /// <summary>
        /// Initializes a new instance of the <see cref="CSharpBinaryOperationBinder"/> class.
        /// </summary>
        /// <param name="operation">The binary operation kind.</param>
        /// <param name="isChecked">True if the operation is defined in a checked context; otherwise false.</param>
        /// <param name="binaryOperationFlags">The flags associated with this binary operation.</param>
        /// <param name="callingContext">The <see cref="Type"/> that indicates where this operation is defined.</param>
        /// <param name="argumentInfo">The sequence of <see cref="CSharpArgumentInfo"/> instances for the arguments to this operation.</param>
        public CSharpBinaryOperationBinder(
            ExpressionType operation,
            bool isChecked,
            CSharpBinaryOperationFlags binaryOperationFlags,
            Type callingContext,
            IEnumerable<CSharpArgumentInfo> argumentInfo) :
            base(operation)
        {
            _binopFlags = binaryOperationFlags;
            _argumentInfo = BinderHelper.ToArray(argumentInfo);
            Debug.Assert(_argumentInfo.Length == 2);
            _binder = new RuntimeBinder(callingContext, isChecked);
        }

        /// <summary>
        /// Performs the binding of the binary dynamic operation if the target dynamic object cannot bind.
        /// </summary>
        /// <param name="target">The target of the dynamic binary operation.</param>
        /// <param name="arg">The right hand side operand of the dynamic binary operation.</param>
        /// <param name="errorSuggestion">The binding result in case the binding fails, or null.</param>
        /// <returns>The <see cref="DynamicMetaObject"/> representing the result of the binding.</returns>
        public override DynamicMetaObject FallbackBinaryOperation(DynamicMetaObject target, DynamicMetaObject arg, DynamicMetaObject errorSuggestion)
        {
            BinderHelper.ValidateBindArgument(target, nameof(target));
            BinderHelper.ValidateBindArgument(arg, nameof(arg));
            return BinderHelper.Bind(this, _binder, new [] {target, arg}, _argumentInfo, errorSuggestion);
        }
    }
}