text:
using System;
using System.Globalization;

/// <summary>
/// System.Convert.ToDecimal(Object,IFormatProvider)
/// </summary>
public class ConvertToDecimal15
{
    #region Public Methods
    public bool RunTests()
    {
        bool retVal = true;

        TestLibrary.TestFramework.LogInformation("[Positive]");
        retVal = PosTest1() && retVal;
        retVal = PosTest2() && retVal;
        retVal = PosTest3() && retVal;
        retVal = PosTest4() && retVal;
        retVal = PosTest5() && retVal;
        retVal = PosTest6() && retVal;

        TestLibrary.TestFramework.LogInformation("[Negative]");
        retVal = NegTest1() && retVal;

        return retVal;
    }

    #region Positive Test Cases
    public bool PosTest1()
    {
        bool retVal = true;

        TestLibrary.TestFramework.BeginScenario("PosTest1: The object is a byte");

        try
        {
            byte i = TestLibrary.Generator.GetByte(-55);
            object ob = i;
            IFormatProvider iFormatProvider = new CultureInfo("en-US");
            decimal decimalValue = Convert.ToDecimal(ob, iFormatProvider);
            if (decimalValue != i)
            {
                TestLibrary.TestFramework.LogError("001", "The result is not the value as expected,i is" + i);
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e);
            retVal = false;
        }

        return retVal;
    }

    public bool PosTest2()
    {
        bool retVal = true;

        TestLibrary.TestFramework.BeginScenario("PosTest2: The object is an int32");

        try
        {
            Int32 i = TestLibrary.Generator.GetInt32(-55);
            object ob = i;
            IFormatProvider iFormatProvider = new CultureInfo("fr-FR");
            decimal decimalValue = Convert.ToDecimal(ob, iFormatProvider);
            if (decimalValue != i)
            {
                TestLibrary.TestFramework.LogError("003", "The result is not the value as expected,i is" + i);
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("004", "Unexpected exception: " + e);
            retVal = false;
        }

        return retVal;
    }

    public bool PosTest3()
    {
        bool retVal = true;

        TestLibrary.TestFramework.BeginScenario("PosTest3: The object is a double and the Iformatprovider is a null reference");

        try
        {
            double i = TestLibrary.Generator.GetDouble(-55);
            object ob = i;
            IFormatProvider iFormatProvider = null;
            decimal decimalValue = Convert.ToDecimal(ob, iFormatProvider);
            if (decimalValue != (i as IConvertible).ToDecimal(null))
            {
                TestLibrary.TestFramework.LogError("005", "The result is not the value as expected,i is" + i);
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("006", "Unexpected exception: " + e);
            retVal = false;
        }

        return retVal;
    }

    public bool PosTest4()
    {
        bool retVal = true;

        TestLibrary.TestFramework.BeginScenario("PosTest4: The object is a string and the cultureinfo is fr-FR");

        try
        {
            string i = "-100 123 456";
            object ob = i;
            IFormatProvider iFormatProvider = new CultureInfo("fr-FR");
            decimal decimalValue = Convert.ToDecimal(ob, iFormatProvider);
            if (decimalValue != -100123456)
            {
                TestLibrary.TestFramework.LogError("007", "The result is not the value as expected,i is" + i);
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("008", "Unexpected exception: " + e);
            retVal = false;
        }

        return retVal;
    }

    public bool PosTest5()
    {
        bool retVal = true;

        TestLibrary.TestFramework.BeginScenario("PosTest5: The object is a string and the cultureinfo is en-US");

        try
        {
            string i = "-100,123,456.12345";
            object ob = i;
            IFormatProvider iFormatProvider = new CultureInfo("en-US");
            decimal decimalValue = Convert.ToDecimal(ob, iFormatProvider);
            if (decimalValue != -100123456.12345M)
            {
                TestLibrary.TestFramework.LogError("009", "The result is not the value as expected,i is" + i);
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("010", "Unexpected exception: " + e);
            retVal = false;
        }

        return retVal;
    }

    public bool PosTest6()
    {
        bool retVal = true;

        TestLibrary.TestFramework.BeginScenario("PosTest6: The object is a custom class which implement the iconvertible interface");

        try
        {
            MyClass myClass = new MyClass();
            object ob = myClass;
            IFormatProvider iFormatProvider = new CultureInfo("en-US");
            decimal decimalValue = Convert.ToDecimal(ob, iFormatProvider);
            if (decimalValue != -1)
            {
                TestLibrary.TestFramework.LogError("011", "The result is not the value as expected");
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("012", "Unexpected exception: " + e);
            retVal = false;
        }

        return retVal;
    }
    #endregion

    #region Nagetive Test Cases
    public bool NegTest1()
    {
        bool retVal = true;

        TestLibrary.TestFramework.BeginScenario("NegTest1: The conversion is invalid");

        try
        {
            char i = '1';
            object ob = i;
            IFormatProvider iFormatProvider = new CultureInfo("en-US");
            decimal decimalValue = Convert.ToDecimal(ob, iFormatProvider);
            TestLibrary.TestFramework.LogError("101", "The InvalidCastException was not thrown as expected");
            retVal = false;
        }
        catch (InvalidCastException)
        {
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("102", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogInformation(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }
    #endregion
    #endregion

    public static int Main()
    {
        ConvertToDecimal15 test = new ConvertToDecimal15();

        TestLibrary.TestFramework.BeginTestCase("ConvertToDecimal15");

        if (test.RunTests())
        {
            TestLibrary.TestFramework.EndTestCase();
            TestLibrary.TestFramework.LogInformation("PASS");
            return 100;
        }
        else
        {
            TestLibrary.TestFramework.EndTestCase();
            TestLibrary.TestFramework.LogInformation("FAIL");
            return 0;
        }
    }
}
public class MyClass : IConvertible
{
    #region IConvertible Members

    public TypeCode GetTypeCode()
    {
        throw new System.Exception("The method or operation is not implemented.");
    }

    public bool ToBoolean(IFormatProvider provider)
    {
        throw new System.Exception("The method or operation is not implemented.");
    }

    public byte ToByte(IFormatProvider provider)
    {
        throw new System.Exception("The method or operation is not implemented.");
    }

    public char ToChar(IFormatProvider provider)
    {
        throw new System.Exception("The method or operation is not implemented.");
    }

    public DateTime ToDateTime(IFormatProvider provider)
    {
        throw new System.Exception("The method or operation is not implemented.");
    }

    public decimal ToDecimal(IFormatProvider provider)
    {
        if (((CultureInfo)provider).Equals(new CultureInfo("en-US")))
        {
            return -1;
        }
        if (((CultureInfo)provider).Equals(new CultureInfo("fr-FR")))
        {
            return 1;
        }
        return 0;
    }

    public double ToDouble(IFormatProvider provider)
    {
        throw new System.Exception("The method or operation is not implemented.");
    }

    public short ToInt16(IFormatProvider provider)
    {
        throw new System.Exception("The method or operation is not implemented.");
    }

    public int ToInt32(IFormatProvider provider)
    {
        throw new System.Exception("The method or operation is not implemented.");
    }

    public long ToInt64(IFormatProvider provider)
    {
        throw new System.Exception("The method or operation is not implemented.");
    }

    public sbyte ToSByte(IFormatProvider provider)
    {
        throw new System.Exception("The method or operation is not implemented.");
    }

    public float ToSingle(IFormatProvider provider)
    {
        throw new System.Exception("The method or operation is not implemented.");
    }

    public string ToString(IFormatProvider provider)
    {
        throw new System.Exception("The method or operation is not implemented.");
    }

    public object ToType(Type conversionType, IFormatProvider provider)
    {
        throw new System.Exception("The method or operation is not implemented.");
    }

    public ushort ToUInt16(IFormatProvider provider)
    {
        throw new System.Exception("The method or operation is not implemented.");
    }

    public uint ToUInt32(IFormatProvider provider)
    {
        throw new System.Exception("The method or operation is not implemented.");
    }

    public ulong ToUInt64(IFormatProvider provider)
    {
        throw new System.Exception("The method or operation is not implemented.");
    }

    #endregion
}


text:
<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2007 The Android Open Source Project

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
-->

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <EditText android:id="@+id/anchor"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:textSize="20sp"
        android:text="@string/baseline_6_multi_line" />

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignBaseline="@id/anchor"
        android:layout_alignRight="@id/anchor"
        android:text="@string/baseline_6_baseline" />

</RelativeLayout>

redpajama_set_name: RedPajamaGithub


text:
class StatisticsService
  class << self
    def calculate
      list = user_stats
      list.concat project_stats
      list.concat favorite_stats
    end

    private

    def user_stats
      [{ :icon => 'users', :title => '.user_count',
         :count => User.count },
       { :icon => 'users', :title => '.user_count_today',
         :count => today(User) },
       { :icon => 'users', :title => '.user_count_yesterday',
         :count => yesterday(User) }]
    end

    def project_stats
      [{ :icon => 'book', :title => '.project_count',
         :count => Project.count },
       { :icon => 'book', :title => '.project_count_today',
         :count => today(Project) },
       { :icon => 'book', :title => '.project_count_yesterday',
         :count => yesterday(Project) }]
    end

    def favorite_stats
      [{ :icon => 'star', :title => '.favorites_count',
         :count => Favorite.count }]
    end

    def yesterday(scope)
      scope.where(:created_at => Date.yesterday.beginning_of_day..Date
           .yesterday.end_of_day).count
    end

    def today(scope)
      scope.where('created_at > ?', Date.today.beginning_of_day).count
    end
  end
end


text:
from django.conf.urls.defaults import url, patterns, include
from django.views.generic.list_detail import object_list
from django.views.generic.simple import direct_to_template

from tagging.models import Tag

from emptyheap import views
from emptyheap.models import Question, Answer

urlpatterns = patterns('',
    url(r'^$',
        object_list,
        {'queryset': Question.objects.get_top_questions()},
        name='eh_index'),

    url(r'^questions/$',
        object_list,
        {'queryset': Question.objects.all()},
        name='eh_questions'),

    url(r'^tags/$',
        direct_to_template, {
        'template': 'emptyheap/tag_list.html',
        'extra_context': {'tags': Tag.objects.cloud_for_model(Question, steps=5)}},
        name='eh_tags'),

    url(r'^tags/(?P<tag_name>[-\w]+)/$',
        views.tag_detail,
        name='eh_tag_detail'),

    url(r'^unanswered/$',
        object_list,
        {'queryset': Question.objects.unanswered()},
        name='eh_unanswered'),

    url(r'^ask/$',
        views.ask,
        name='eh_ask'),

    url(r'^questions/(?P<question__id>\d+)/(?P<id>\d+)/vote/',
        include(views.ObjectVoteView(Answer).urls)),

    url(r'^questions/(?P<id>\d+)/vote/',
        include(views.ObjectVoteView(Question).urls)),

    url(r'^questions/(?P<question_id>\d+)/', # Note that it doesnt end in $ for slug
        views.question_detail,
        name='eh_question_detail'),
)


text:
package ch.thn.objectdebugger.processors;

import java.util.List;

import javax.swing.JTextField;

import ch.thn.util.object.ObjectTreeProcessor;

/**
 *
 * @author Thomas Naeff (github.com/thnaeff)
 *
 */
public class JTextFieldProcessor extends ObjectTreeProcessor<JTextField> {

	/**
	 *
	 *
	 */
	public JTextFieldProcessor() {
		super(JTextField.class);
	}

	@Override
	public List<?> getInternalObjects(JTextField obj) {
		return createSingleItemList(obj.getDocument());
	}

}


text:
using FellSky.Components;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Artemis;
using FellSky.Services;
using LibRocketNet;
using System.Diagnostics;

namespace FellSky.Systems
{
    class GuiSystem : Artemis.System.EntitySystem
    {
        const string PreviousDisplayPropertyAttributeName = "__previousDisplayProp";
        private IGuiService _service;
        private ElementDocument _document;
        private Dictionary<Entity, Element> _elements = new Dictionary<Entity, Element>();

        public GuiSystem(): base(Aspect.All(typeof(GuiComponent)))
        {
            _service = ServiceLocator.Instance.GetService<IGuiService>();
        }

        public override void LoadContent()
        {
            _document = _service.Context.LoadDocument(Properties.Settings.Default.GuiDocument);
            _document.Show(ElementDocument.FocusFlags.None);
            base.LoadContent();
        }

        public override void UnloadContent()
        {
            _document.Close();
            _document.Dispose();
            base.UnloadContent();
        }

        public override void OnAdded(Entity entity)
        {
            var component = entity.GetComponent<GuiComponent>();
            if (component.Element == null) return;
            if(component.Element.ParentNode == null)
            {
                _document.AppendChild(component.Element);
            }
            _elements[entity] = component.Element;
            base.OnAdded(entity);
        }

        public override void OnRemoved(Entity entity)
        {
            var element = _elements[entity];
            _elements.Remove(entity);
            if (element == null) return;
            element.ParentNode?.RemoveChild(element);
            base.OnRemoved(entity);
        }

        public override void Process()
        {
            _service.Context.Render();
        }

        public override void OnDisabled(Entity entity)
        {
            var component = entity.GetComponent<GuiComponent>();
            if (component==null || component.Element == null) return;
            component.Element.SetAttribute(PreviousDisplayPropertyAttributeName, component.Element.GetPropertyString("display"));
            component.Element.SetProperty("display", "none");

            base.OnDisabled(entity);
        }

        public override void OnEnabled(Entity entity)
        {
            var component = entity.GetComponent<GuiComponent>();
            if (component == null || component.Element == null) return;
            var attr = component.Element.GetAttributeString(PreviousDisplayPropertyAttributeName, "block");
            component.Element.SetProperty("display", attr);
            base.OnEnabled(entity);
        }
    }
}


text:
import os

from flask import current_app

from elasticutils import S

class ElasticUtils(object):
    """
    A thin wrapper around elasticutils
    """
    def __init__(self, app=None):
        if app is not None:
            self.init_app(app)

    def init_app(self, app):
        app.config.setdefault('ELASTICSEARCH_URL',
                os.environ.get('ELASTICSEARCH_URL', 'localhost:9200'))

        if not hasattr(app, 'extensions'):
            app.extensions = {}

        app.extensions['elasticutils'] = S().es(urls=[app.config['ELASTICSEARCH_URL']])

    def __getattr__(self, item):
        if not 'elasticutils' in current_app.extensions.keys():
            raise Exception('not initialised, did you forget to call init_app?')
        return getattr(current_app.extensions['elasticutils'], item)


text:
/*************************************************************************************************

*Filename: unsignedint.c
*Authors: Andrew Lamb
*Last Modified: 24/12/2012
*Description:	Program is an example of what happens when
				you try to put a negative value into an unsigned integer

*************************************************************************************************/

#include <stdio.h>

int main(void)
{
	unsigned int t = 1;	//create unsigned int and initialise to value 1

	printf("Unsigned int t has a value of:%u\n",t); //display unsigned int value
	t = t - 2;
	printf("t minus 2 =:%u\n",t); //large number should be displayed because unsigned int cannot hold negative values

	return 0;	//all Ok
}


text:
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
// Code generated by Microsoft (R) AutoRest Code Generator.

package com.azure.resourcemanager.sql.generated;

import com.azure.core.util.Context;

/** Samples for PrivateEndpointConnections ListByServer. */
public final class PrivateEndpointConnectionsListByServerSamples {
    /*
     * x-ms-original-file: specification/sql/resource-manager/Microsoft.Sql/preview/2018-06-01-preview/examples/PrivateEndpointConnectionList.json
     */
    /**
     * Sample code: Gets list of private endpoint connections on a server.
     *
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void getsListOfPrivateEndpointConnectionsOnAServer(
        com.azure.resourcemanager.AzureResourceManager azure) {
        azure
            .sqlServers()
            .manager()
            .serviceClient()
            .getPrivateEndpointConnections()
            .listByServer("Default", "test-svr", Context.NONE);
    }
}


text:
<?php

if (!defined('PHP5')) {
	define('PHP5', (PHP_VERSION >= 5));
}
if (!defined('E_DEPRECATED')) {
	define('E_DEPRECATED', 8192);
}
error_reporting(E_ALL & ~E_DEPRECATED & ~E_STRICT);

require CORE_PATH . 'cake' . DS . 'basics.php';
$TIME_START = getMicrotime();
require CORE_PATH . 'cake' . DS . 'config' . DS . 'paths.php';
require LIBS . 'object.php';
require LIBS . 'inflector.php';
require LIBS . 'configure.php';
require LIBS . 'set.php';
require LIBS . 'cache.php';
Configure::getInstance();
require CAKE . 'dispatcher.php';


text:
=begin
  @Author: Ernestas Poskus
  @Author-URI: out13.com

  @LinkedIn: linkedin.com/in/ernestasposkus/
  @GitHub: github.com/ernestas-poskus

  -----
  @date: 12/2/13 - 5:29 PM
  Project: Singleton pattern

  @Definition: it allows you to have one and only one instance of a class in your system.
  * Singleton pattern - by some considered grand daddy of all patterns.
  * Considered as "Global" variable which undermines encapsulation.

  @Pros:
  - Makes Object/Method available throughout system
  - Object/Method should not be stored in global variable, which can be overwritten
  - Only 1 Object/Method and no more available in the system.
  - Improvement over Global variables
  - Cannot overwrite data

  @Cons:
  - Hard to debug/ test
  - Dependency problems

=end

class Singleton1

  attr_accessor :var
  @@instance = nil
  @var = nil

  private_class_method :new # Disable initializing

  def self.instance()
    @@instance ||= new
  end

  def log
     'Logged'
  end

  def dup
    raise TypeError, "can't dup instance of singleton #{self.class}"
  end

  def clone
    raise TypeError, "can't clone instance of singleton #{self.class}"
  end

end


text:
<?php

namespace Symfony\Component\Security\Core\Tests\Authentication;

use PHPUnit\Framework\TestCase;
use Symfony\Component\Security\Core\Authentication\AuthenticationTrustResolver;
use Symfony\Component\Security\Core\Authentication\Token\AnonymousToken;
use Symfony\Component\Security\Core\Authentication\Token\RememberMeToken;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;

class AuthenticationTrustResolverTest extends TestCase
{
    public function testIsAnonymous()
    {
        $resolver = new AuthenticationTrustResolver();
        $this->assertFalse($resolver->isAnonymous(null));
        $this->assertFalse($resolver->isAnonymous($this->getToken()));
        $this->assertFalse($resolver->isAnonymous($this->getRememberMeToken()));
        $this->assertFalse($resolver->isAnonymous(new FakeCustomToken()));
        $this->assertTrue($resolver->isAnonymous(new RealCustomAnonymousToken()));
        $this->assertTrue($resolver->isAnonymous($this->getAnonymousToken()));
    }

    public function testIsRememberMe()
    {
        $resolver = new AuthenticationTrustResolver();

        $this->assertFalse($resolver->isRememberMe(null));
        $this->assertFalse($resolver->isRememberMe($this->getToken()));
        $this->assertFalse($resolver->isRememberMe($this->getAnonymousToken()));
        $this->assertFalse($resolver->isRememberMe(new FakeCustomToken()));
        $this->assertTrue($resolver->isRememberMe(new RealCustomRememberMeToken()));
        $this->assertTrue($resolver->isRememberMe($this->getRememberMeToken()));
    }

    public function testisFullFledged()
    {
        $resolver = new AuthenticationTrustResolver();

        $this->assertFalse($resolver->isFullFledged(null));
        $this->assertFalse($resolver->isFullFledged($this->getAnonymousToken()));
        $this->assertFalse($resolver->isFullFledged($this->getRememberMeToken()));
        $this->assertFalse($resolver->isFullFledged(new RealCustomAnonymousToken()));
        $this->assertFalse($resolver->isFullFledged(new RealCustomRememberMeToken()));
        $this->assertTrue($resolver->isFullFledged($this->getToken()));
        $this->assertTrue($resolver->isFullFledged(new FakeCustomToken()));
    }

    public function testIsAnonymousWithClassAsConstructorButStillExtending()
    {
        $resolver = $this->getResolver();

        $this->assertFalse($resolver->isAnonymous(null));
        $this->assertFalse($resolver->isAnonymous($this->getToken()));
        $this->assertFalse($resolver->isAnonymous($this->getRememberMeToken()));
        $this->assertTrue($resolver->isAnonymous($this->getAnonymousToken()));
        $this->assertTrue($resolver->isAnonymous(new RealCustomAnonymousToken()));
    }

    public function testIsRememberMeWithClassAsConstructorButStillExtending()
    {
        $resolver = $this->getResolver();

        $this->assertFalse($resolver->isRememberMe(null));
        $this->assertFalse($resolver->isRememberMe($this->getToken()));
        $this->assertFalse($resolver->isRememberMe($this->getAnonymousToken()));
        $this->assertTrue($resolver->isRememberMe($this->getRememberMeToken()));
        $this->assertTrue($resolver->isRememberMe(new RealCustomRememberMeToken()));
    }

    public function testisFullFledgedWithClassAsConstructorButStillExtending()
    {
        $resolver = $this->getResolver();

        $this->assertFalse($resolver->isFullFledged(null));
        $this->assertFalse($resolver->isFullFledged($this->getAnonymousToken()));
        $this->assertFalse($resolver->isFullFledged($this->getRememberMeToken()));
        $this->assertFalse($resolver->isFullFledged(new RealCustomAnonymousToken()));
        $this->assertFalse($resolver->isFullFledged(new RealCustomRememberMeToken()));
        $this->assertTrue($resolver->isFullFledged($this->getToken()));
    }

    protected function getToken()
    {
        return $this->createMock(TokenInterface::class);
    }

    protected function getAnonymousToken()
    {
        return $this->getMockBuilder(AnonymousToken::class)->setConstructorArgs(['', ''])->getMock();
    }

    protected function getRememberMeToken()
    {
        return $this->getMockBuilder(RememberMeToken::class)->setMethods(['setPersistent'])->disableOriginalConstructor()->getMock();
    }

    protected function getResolver()
    {
        return new AuthenticationTrustResolver(
            AnonymousToken::class,
            RememberMeToken::class
        );
    }
}

class FakeCustomToken implements TokenInterface
{
    public function __serialize(): array
    {
    }

    public function serialize(): string
    {
    }

    public function __unserialize(array $data): void
    {
    }

    public function unserialize($serialized)
    {
    }

    public function __toString(): string
    {
    }

    public function getRoleNames(): array
    {
    }

    public function getCredentials()
    {
    }

    public function getUser()
    {
    }

    public function setUser($user)
    {
    }

    public function getUsername(): string
    {
    }

    public function getUserIdentifier(): string
    {
    }

    public function isAuthenticated(): bool
    {
    }

    public function setAuthenticated(bool $isAuthenticated)
    {
    }

    public function eraseCredentials()
    {
    }

    public function getAttributes(): array
    {
    }

    public function setAttributes(array $attributes)
    {
    }

    public function hasAttribute(string $name): bool
    {
    }

    public function getAttribute(string $name)
    {
    }

    public function setAttribute(string $name, $value)
    {
    }
}

class RealCustomAnonymousToken extends AnonymousToken
{
    public function __construct()
    {
    }
}

class RealCustomRememberMeToken extends RememberMeToken
{
    public function __construct()
    {
    }
}


text:
/* TEMPLATE GENERATED TESTCASE FILE
Filename: CWE122_Heap_Based_Buffer_Overflow__sizeof_struct_62b.cpp
Label Definition File: CWE122_Heap_Based_Buffer_Overflow__sizeof.label.xml
Template File: sources-sink-62b.tmpl.cpp
*/
/*
 * @description
 * CWE: 122 Heap Based Buffer Overflow
 * BadSource:  Initialize the source buffer using the size of a pointer
 * GoodSource: Initialize the source buffer using the size of the DataElementType
 * Sinks:
 *    BadSink : Print then free data
 * Flow Variant: 62 Data flow: data flows using a C++ reference from one function to another in different source files
 *
 * */

#include "std_testcase.h"

namespace CWE122_Heap_Based_Buffer_Overflow__sizeof_struct_62
{

#ifndef OMITBAD

void badSource(twoIntsStruct * &data)
{
    /* INCIDENTAL: CWE-467 (Use of sizeof() on a pointer type) */
    /* FLAW: Using sizeof the pointer and not the data type in malloc() */
    data = (twoIntsStruct *)malloc(sizeof(data));
    data->intOne = 1;
    data->intTwo = 2;
}

#endif /* OMITBAD */

#ifndef OMITGOOD

/* goodG2B() uses the GoodSource with the BadSink */
void goodG2BSource(twoIntsStruct * &data)
{
    /* FIX: Using sizeof the data type in malloc() */
    data = (twoIntsStruct *)malloc(sizeof(*data));
    data->intOne = 1;
    data->intTwo = 2;
}

#endif /* OMITGOOD */

} /* close namespace */


text:
package main

import (
	"bytes"
	"flag"
	"fmt"
	"io/fs"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"reflect"
	"regexp"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"time"
)

func cmdtest() {
	gogcflags = os.Getenv("GO_GCFLAGS")
	setNoOpt()

	var t tester

	var noRebuild bool
	flag.BoolVar(&t.listMode, "list", false, "list available tests")
	flag.BoolVar(&t.rebuild, "rebuild", false, "rebuild everything first")
	flag.BoolVar(&noRebuild, "no-rebuild", false, "overrides -rebuild (historical dreg)")
	flag.BoolVar(&t.keepGoing, "k", false, "keep going even when error occurred")
	flag.BoolVar(&t.race, "race", false, "run in race builder mode (different set of tests)")
	flag.BoolVar(&t.compileOnly, "compile-only", false, "compile tests, but don't run them. This is for some builders. Not all dist tests respect this flag, but most do.")
	flag.StringVar(&t.banner, "banner", "##### ", "banner prefix; blank means no section banners")
	flag.StringVar(&t.runRxStr, "run", os.Getenv("GOTESTONLY"),
		"run only those tests matching the regular expression; empty means to run all. "+
			"Special exception: if the string begins with '!', the match is inverted.")
	flag.BoolVar(&t.msan, "msan", false, "run in memory sanitizer builder mode")
	flag.BoolVar(&t.asan, "asan", false, "run in address sanitizer builder mode")

	xflagparse(-1) // any number of args
	if noRebuild {
		t.rebuild = false
	}

	t.run()
}

// tester executes cmdtest.
type tester struct {
	race        bool
	msan        bool
	asan        bool
	listMode    bool
	rebuild     bool
	failed      bool
	keepGoing   bool
	compileOnly bool // just try to compile all tests, but no need to run
	runRxStr    string
	runRx       *regexp.Regexp
	runRxWant   bool     // want runRx to match (true) or not match (false)
	runNames    []string // tests to run, exclusive with runRx; empty means all
	banner      string   // prefix, or "" for none
	lastHeading string   // last dir heading printed

	short      bool
	cgoEnabled bool
	partial    bool

	goExe    string // For host tests
	goTmpDir string // For host tests

	tests        []distTest
	timeoutScale int

	worklist []*work
}

type work struct {
	dt    *distTest
	cmd   *exec.Cmd
	start chan bool
	out   []byte
	err   error
	end   chan bool
}

// A distTest is a test run by dist test.
// Each test has a unique name and belongs to a group (heading)
type distTest struct {
	name    string // unique test name; may be filtered with -run flag
	heading string // group section; this header is printed before the test is run.
	fn      func(*distTest) error
}

func (t *tester) run() {
	timelog("start", "dist test")

	os.Setenv("PATH", fmt.Sprintf("%s%c%s", gorootBin, os.PathListSeparator, os.Getenv("PATH")))

	// Default to running tests in "short" mode, unless the environment variable
	// GO_TEST_SHORT is set to a non-empty, false-ish string.
	//
	// This environment variable is meant to be an internal detail between the
	// Go build system and cmd/dist for the purpose of longtest builders, and is
	// not intended for use by users. See golang.org/issue/12508.
	t.short = true
	if v := os.Getenv("GO_TEST_SHORT"); v != "" {
		short, err := strconv.ParseBool(v)
		if err != nil {
			fatalf("invalid GO_TEST_SHORT %q: %v", v, err)
		}
		t.short = short
	}

	cmd := exec.Command(gorootBinGo, "env", "CGO_ENABLED", "GOEXE", "GOTMPDIR")
	cmd.Stderr = new(bytes.Buffer)
	slurp, err := cmd.Output()
	if err != nil {
		fatalf("Error running %s: %v\n%s", cmd, err, cmd.Stderr)
	}
	parts := strings.Split(string(slurp), "\n")
	if len(parts) < 3 {
		fatalf("Error running %s: output contains <3 lines\n%s", cmd, cmd.Stderr)
	}
	t.cgoEnabled, _ = strconv.ParseBool(parts[0])
	t.goExe = parts[1]
	t.goTmpDir = parts[2]

	if flag.NArg() > 0 && t.runRxStr != "" {
		fatalf("the -run regular expression flag is mutually exclusive with test name arguments")
	}

	t.runNames = flag.Args()

	// Set GOTRACEBACK to system if the user didn't set a level explicitly.
	// Since we're running tests for Go, we want as much detail as possible
	// if something goes wrong.
	//
	// Set it before running any commands just in case something goes wrong.
	if ok := isEnvSet("GOTRACEBACK"); !ok {
		if err := os.Setenv("GOTRACEBACK", "system"); err != nil {
			if t.keepGoing {
				log.Printf("Failed to set GOTRACEBACK: %v", err)
			} else {
				fatalf("Failed to set GOTRACEBACK: %v", err)
			}
		}
	}

	if t.rebuild {
		t.out("Building packages and commands.")
		// Force rebuild the whole toolchain.
		goInstall("go", append([]string{"-a"}, toolchain...)...)
	}

	if !t.listMode {
		if builder := os.Getenv("GO_BUILDER_NAME"); builder == "" {
			// Complete rebuild bootstrap, even with -no-rebuild.
			// If everything is up-to-date, this is a no-op.
			// If everything is not up-to-date, the first checkNotStale
			// during the test process will kill the tests, so we might
			// as well install the world.
			// Now that for example "go install cmd/compile" does not
			// also install runtime (you need "go install -i cmd/compile"
			// for that), it's easy for previous workflows like
			// "rebuild the compiler and then run run.bash"
			// to break if we don't automatically refresh things here.
			// Rebuilding is a shortened bootstrap.
			// See cmdbootstrap for a description of the overall process.
			goInstall("go", toolchain...)
			goInstall("go", toolchain...)
			goInstall("go", "std", "cmd")
		} else {
			// The Go builder infrastructure should always begin running tests from a
			// clean, non-stale state, so there is no need to rebuild the world.
			// Instead, we can just check that it is not stale, which may be less
			// expensive (and is also more likely to catch bugs in the builder
			// implementation).
			// The cache used by dist when building is different from that used when
			// running dist test, so rebuild (but don't install) std and cmd to make
			// sure packages without install targets are cached so they are not stale.
			goCmd("go", "build", "std", "cmd") // make sure dependencies of targets are cached
			if builder == "aix-ppc64" {
				// The aix-ppc64 builder for some reason does not have deterministic cgo
				// builds, so "cmd" is stale. Fortunately, most of the tests don't care.
				// TODO(#56896): remove this special case once the builder supports
				// determistic cgo builds.
				checkNotStale("go", "std")
			} else {
				checkNotStale("go", "std", "cmd")
			}
		}
	}

	t.timeoutScale = 1
	switch goarch {
	case "arm":
		t.timeoutScale = 2
	case "mips", "mipsle", "mips64", "mips64le":
		t.timeoutScale = 4
	}
	if s := os.Getenv("GO_TEST_TIMEOUT_SCALE"); s != "" {
		t.timeoutScale, err = strconv.Atoi(s)
		if err != nil {
			fatalf("failed to parse $GO_TEST_TIMEOUT_SCALE = %q as integer: %v", s, err)
		}
	}

	if t.runRxStr != "" {
		if t.runRxStr[0] == '!' {
			t.runRxWant = false
			t.runRxStr = t.runRxStr[1:]
		} else {
			t.runRxWant = true
		}
		t.runRx = regexp.MustCompile(t.runRxStr)
	}

	t.registerTests()
	if t.listMode {
		for _, tt := range t.tests {
			fmt.Println(tt.name)
		}
		return
	}

	for _, name := range t.runNames {
		if !t.isRegisteredTestName(name) {
			fatalf("unknown test %q", name)
		}
	}

	// On a few builders, make GOROOT unwritable to catch tests writing to it.
	if strings.HasPrefix(os.Getenv("GO_BUILDER_NAME"), "linux-") {
		if os.Getuid() == 0 {
			// Don't bother making GOROOT unwritable:
			// we're running as root, so permissions would have no effect.
		} else {
			xatexit(t.makeGOROOTUnwritable())
		}
	}

	if err := t.maybeLogMetadata(); err != nil {
		t.failed = true
		if t.keepGoing {
			log.Printf("Failed logging metadata: %v", err)
		} else {
			fatalf("Failed logging metadata: %v", err)
		}
	}

	for _, dt := range t.tests {
		if !t.shouldRunTest(dt.name) {
			t.partial = true
			continue
		}
		dt := dt // dt used in background after this iteration
		if err := dt.fn(&dt); err != nil {
			t.runPending(&dt) // in case that hasn't been done yet
			t.failed = true
			if t.keepGoing {
				log.Printf("Failed: %v", err)
			} else {
				fatalf("Failed: %v", err)
			}
		}
	}
	t.runPending(nil)
	timelog("end", "dist test")

	if t.failed {
		fmt.Println("\nFAILED")
		xexit(1)
	} else if incomplete[goos+"/"+goarch] {
		// The test succeeded, but consider it as failed so we don't
		// forget to remove the port from the incomplete map once the
		// port is complete.
		fmt.Println("\nFAILED (incomplete port)")
		xexit(1)
	} else if t.partial {
		fmt.Println("\nALL TESTS PASSED (some were excluded)")
	} else {
		fmt.Println("\nALL TESTS PASSED")
	}
}

func (t *tester) shouldRunTest(name string) bool {
	if t.runRx != nil {
		return t.runRx.MatchString(name) == t.runRxWant
	}
	if len(t.runNames) == 0 {
		return true
	}
	for _, runName := range t.runNames {
		if runName == name {
			return true
		}
	}
	return false
}

func (t *tester) maybeLogMetadata() error {
	if t.compileOnly {
		// We need to run a subprocess to log metadata. Don't do that
		// on compile-only runs.
		return nil
	}
	t.out("Test execution environment.")
	// Helper binary to print system metadata (CPU model, etc). This is a
	// separate binary from dist so it need not build with the bootstrap
	// toolchain.
	//
	// TODO(prattmic): If we split dist bootstrap and dist test then this
	// could be simplified to directly use internal/sysinfo here.
	return t.dirCmd(filepath.Join(goroot, "src/cmd/internal/metadata"), "go", []string{"run", "main.go"}).Run()
}

// goTest represents all options to a "go test" command. The final command will
// combine configuration from goTest and tester flags.
type goTest struct {
	timeout  time.Duration // If non-zero, override timeout
	short    bool          // If true, force -short
	tags     []string      // Build tags
	race     bool          // Force -race
	bench    bool          // Run benchmarks (briefly), not tests.
	runTests string        // Regexp of tests to run
	cpu      string        // If non-empty, -cpu flag
	goroot   string        // If non-empty, use alternate goroot for go command

	gcflags   string // If non-empty, build with -gcflags=all=X
	ldflags   string // If non-empty, build with -ldflags=X
	buildmode string // If non-empty, -buildmode flag

	dir string   // If non-empty, run in GOROOT/src-relative directory dir
	env []string // Environment variables to add, as KEY=VAL. KEY= unsets a variable

	// We have both pkg and pkgs as a convenience. Both may be set, in which
	// case they will be combined. If both are empty, the default is ".".
	pkgs []string // Multiple packages to test
	pkg  string   // A single package to test

	testFlags []string // Additional flags accepted by this test
}

// bgCommand returns a go test Cmd. The result has Stdout and Stderr set to nil
// and is intended to be added to the work queue.
func (opts *goTest) bgCommand(t *tester) *exec.Cmd {
	goCmd, build, run, pkgs, setupCmd := opts.buildArgs(t)

	// Combine the flags.
	args := append([]string{"test"}, build...)
	if t.compileOnly {
		// We can't pass -c with multiple packages, so run the tests but
		// tell them not to do anything.
		args = append(args, "-run=^$")
	} else {
		args = append(args, run...)
	}
	args = append(args, pkgs...)
	if !t.compileOnly {
		args = append(args, opts.testFlags...)
	}

	cmd := exec.Command(goCmd, args...)
	setupCmd(cmd)

	return cmd
}

// command returns a go test Cmd intended to be run immediately.
func (opts *goTest) command(t *tester) *exec.Cmd {
	cmd := opts.bgCommand(t)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	return cmd
}

func (opts *goTest) run(t *tester) error {
	return opts.command(t).Run()
}

// runHostTest runs a test that should be built and run on the host GOOS/GOARCH,
// but run with GOOS/GOARCH set to the target GOOS/GOARCH. This is for tests
// that do nothing but compile and run other binaries. If the host and target
// are different, then the assumption is that the target is running in an
// emulator and does not have a Go toolchain at all, so the test needs to run on
// the host, but its resulting binaries will be run through a go_exec wrapper
// that runs them on the target.
func (opts *goTest) runHostTest(t *tester) error {
	goCmd, build, run, pkgs, setupCmd := opts.buildArgs(t)

	// Build the host test binary
	if len(pkgs) != 1 {
		// We can't compile more than one package.
		panic("host tests must have a single test package")
	}
	if len(opts.env) != 0 {
		// It's not clear if these are for the host or the target.
		panic("host tests must not have environment variables")
	}

	f, err := os.CreateTemp(t.goTmpDir, "test.test-*"+t.goExe)
	if err != nil {
		fatalf("failed to create temporary file: %s", err)
	}
	bin := f.Name()
	f.Close()
	xatexit(func() { os.Remove(bin) })

	args := append([]string{"test", "-c", "-o", bin}, build...)
	args = append(args, pkgs...)
	cmd := exec.Command(goCmd, args...)
	setupCmd(cmd)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	setEnv(cmd, "GOARCH", gohostarch)
	setEnv(cmd, "GOOS", gohostos)
	if vflag > 1 {
		errprintf("%s\n", cmd)
	}
	if err := cmd.Run(); err != nil {
		return err
	}

	if t.compileOnly {
		return nil
	}

	// Transform run flags to be passed directly to a test binary.
	for i, f := range run {
		if !strings.HasPrefix(f, "-") {
			panic("run flag does not start with -: " + f)
		}
		run[i] = "-test." + f[1:]
	}

	// Run the test
	args = append(run, opts.testFlags...)
	cmd = exec.Command(bin, args...)
	setupCmd(cmd)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	if vflag > 1 {
		errprintf("%s\n", cmd)
	}
	return cmd.Run()
}

// buildArgs is in internal helper for goTest that constructs the elements of
// the "go test" command line. goCmd is the path to the go command to use. build
// is the flags for building the test. run is the flags for running the test.
// pkgs is the list of packages to build and run.
//
// The caller is responsible for adding opts.testFlags, and must call setupCmd
// on the resulting exec.Cmd to set its directory and environment.
func (opts *goTest) buildArgs(t *tester) (goCmd string, build, run, pkgs []string, setupCmd func(*exec.Cmd)) {
	goCmd = gorootBinGo
	if opts.goroot != "" {
		goCmd = filepath.Join(opts.goroot, "bin", "go")
	}

	run = append(run, "-count=1") // Disallow caching
	if opts.timeout != 0 {
		d := opts.timeout * time.Duration(t.timeoutScale)
		run = append(run, "-timeout="+d.String())
	}
	if opts.short || t.short {
		run = append(run, "-short")
	}
	var tags []string
	if t.iOS() {
		tags = append(tags, "lldb")
	}
	if noOpt {
		tags = append(tags, "noopt")
	}
	tags = append(tags, opts.tags...)
	if len(tags) > 0 {
		build = append(build, "-tags="+strings.Join(tags, ","))
	}
	if t.race || opts.race {
		build = append(build, "-race")
	}
	if t.msan {
		build = append(build, "-msan")
	}
	if t.asan {
		build = append(build, "-asan")
	}
	if opts.bench {
		// Run no tests.
		run = append(run, "-run=^$")
		// Run benchmarks as a smoke test
		run = append(run, "-bench=.*", "-benchtime=.1s")
	} else if opts.runTests != "" {
		run = append(run, "-run="+opts.runTests)
	}
	if opts.cpu != "" {
		run = append(run, "-cpu="+opts.cpu)
	}

	if opts.gcflags != "" {
		build = append(build, "-gcflags=all="+opts.gcflags)
	}
	if opts.ldflags != "" {
		build = append(build, "-ldflags="+opts.ldflags)
	}
	if opts.buildmode != "" {
		build = append(build, "-buildmode="+opts.buildmode)
	}

	pkgs = opts.pkgs
	if opts.pkg != "" {
		pkgs = append(pkgs[:len(pkgs):len(pkgs)], opts.pkg)
	}
	if len(pkgs) == 0 {
		pkgs = []string{"."}
	}

	thisGoroot := goroot
	if opts.goroot != "" {
		thisGoroot = opts.goroot
	}
	var dir string
	if opts.dir != "" {
		if filepath.IsAbs(opts.dir) {
			panic("dir must be relative, got: " + opts.dir)
		}
		dir = filepath.Join(thisGoroot, "src", opts.dir)
	} else {
		dir = filepath.Join(thisGoroot, "src")
	}
	setupCmd = func(cmd *exec.Cmd) {
		setDir(cmd, dir)
		if len(opts.env) != 0 {
			for _, kv := range opts.env {
				if i := strings.Index(kv, "="); i < 0 {
					unsetEnv(cmd, kv[:len(kv)-1])
				} else {
					setEnv(cmd, kv[:i], kv[i+1:])
				}
			}
		}
	}

	return
}

// ranGoTest and stdMatches are state closed over by the stdlib
// testing func in registerStdTest below. The tests are run
// sequentially, so there's no need for locks.
//
// ranGoBench and benchMatches are the same, but are only used
// in -race mode.
var (
	ranGoTest  bool
	stdMatches []string

	ranGoBench   bool
	benchMatches []string
)

func (t *tester) registerStdTest(pkg string) {
	heading := "Testing packages."
	testPrefix := "go_test:"
	gcflags := gogcflags

	testName := testPrefix + pkg
	if t.runRx == nil || t.runRx.MatchString(testName) == t.runRxWant {
		stdMatches = append(stdMatches, pkg)
	}

	t.tests = append(t.tests, distTest{
		name:    testName,
		heading: heading,
		fn: func(dt *distTest) error {
			if ranGoTest {
				return nil
			}
			t.runPending(dt)
			timelog("start", dt.name)
			defer timelog("end", dt.name)
			ranGoTest = true

			timeoutSec := 180 * time.Second
			for _, pkg := range stdMatches {
				if pkg == "cmd/go" {
					timeoutSec *= 3
					break
				}
			}
			return (&goTest{
				timeout: timeoutSec,
				gcflags: gcflags,
				pkgs:    stdMatches,
			}).run(t)
		},
	})
}

func (t *tester) registerRaceBenchTest(pkg string) {
	testName := "go_test_bench:" + pkg
	if t.runRx == nil || t.runRx.MatchString(testName) == t.runRxWant {
		benchMatches = append(benchMatches, pkg)
	}
	t.tests = append(t.tests, distTest{
		name:    testName,
		heading: "Running benchmarks briefly.",
		fn: func(dt *distTest) error {
			if ranGoBench {
				return nil
			}
			t.runPending(dt)
			timelog("start", dt.name)
			defer timelog("end", dt.name)
			ranGoBench = true
			return (&goTest{
				timeout: 1200 * time.Second, // longer timeout for race with benchmarks
				race:    true,
				bench:   true,
				cpu:     "4",
				pkgs:    benchMatches,
			}).run(t)
		},
	})
}

func (t *tester) registerTests() {
	// Fast path to avoid the ~1 second of `go list std cmd` when
	// the caller lists specific tests to run. (as the continuous
	// build coordinator does).
	if len(t.runNames) > 0 {
		for _, name := range t.runNames {
			if strings.HasPrefix(name, "go_test:") {
				t.registerStdTest(strings.TrimPrefix(name, "go_test:"))
			}
			if strings.HasPrefix(name, "go_test_bench:") {
				t.registerRaceBenchTest(strings.TrimPrefix(name, "go_test_bench:"))
			}
		}
	} else {
		// Use a format string to only list packages and commands that have tests.
		const format = "{{if (or .TestGoFiles .XTestGoFiles)}}{{.ImportPath}}{{end}}"
		cmd := exec.Command(gorootBinGo, "list", "-f", format)
		if t.race {
			cmd.Args = append(cmd.Args, "-tags=race")
		}
		cmd.Args = append(cmd.Args, "std", "cmd")
		cmd.Stderr = new(bytes.Buffer)
		all, err := cmd.Output()
		if err != nil {
			fatalf("Error running go list std cmd: %v:\n%s", err, cmd.Stderr)
		}
		pkgs := strings.Fields(string(all))
		for _, pkg := range pkgs {
			t.registerStdTest(pkg)
		}
		if t.race {
			for _, pkg := range pkgs {
				if t.packageHasBenchmarks(pkg) {
					t.registerRaceBenchTest(pkg)
				}
			}
		}
	}

	if t.race {
		return
	}

	// Test the os/user package in the pure-Go mode too.
	if !t.compileOnly {
		t.registerTest("osusergo", "os/user with tag osusergo",
			&goTest{
				timeout: 300 * time.Second,
				tags:    []string{"osusergo"},
				pkg:     "os/user",
			})
	}

	// Test ios/amd64 for the iOS simulator.
	if goos == "darwin" && goarch == "amd64" && t.cgoEnabled {
		t.registerTest("amd64ios", "GOOS=ios on darwin/amd64",
			&goTest{
				timeout:  300 * time.Second,
				runTests: "SystemRoots",
				env:      []string{"GOOS=ios", "CGO_ENABLED=1"},
				pkg:      "crypto/x509",
			})
	}

	// Runtime CPU tests.
	if !t.compileOnly && goos != "js" { // js can't handle -cpu != 1
		t.registerTest("runtime:cpu124", "GOMAXPROCS=2 runtime -cpu=1,2,4 -quick",
			&goTest{
				timeout:   300 * time.Second,
				cpu:       "1,2,4",
				short:     true,
				testFlags: []string{"-quick"},
				// We set GOMAXPROCS=2 in addition to -cpu=1,2,4 in order to test runtime bootstrap code,
				// creation of first goroutines and first garbage collections in the parallel setting.
				env: []string{"GOMAXPROCS=2"},
				pkg: "runtime",
			})
	}

	// morestack tests. We only run these on in long-test mode
	// (with GO_TEST_SHORT=false) because the runtime test is
	// already quite long and mayMoreStackMove makes it about
	// twice as slow.
	if !t.compileOnly && !t.short {
		// hooks is the set of maymorestack hooks to test with.
		hooks := []string{"mayMoreStackPreempt", "mayMoreStackMove"}
		// pkgs is the set of test packages to run.
		pkgs := []string{"runtime", "reflect", "sync"}
		// hookPkgs is the set of package patterns to apply
		// the maymorestack hook to.
		hookPkgs := []string{"runtime/...", "reflect", "sync"}
		// unhookPkgs is the set of package patterns to
		// exclude from hookPkgs.
		unhookPkgs := []string{"runtime/testdata/..."}
		for _, hook := range hooks {
			// Construct the build flags to use the
			// maymorestack hook in the compiler and
			// assembler. We pass this via the GOFLAGS
			// environment variable so that it applies to
			// both the test itself and to binaries built
			// by the test.
			goFlagsList := []string{}
			for _, flag := range []string{"-gcflags", "-asmflags"} {
				for _, hookPkg := range hookPkgs {
					goFlagsList = append(goFlagsList, flag+"="+hookPkg+"=-d=maymorestack=runtime."+hook)
				}
				for _, unhookPkg := range unhookPkgs {
					goFlagsList = append(goFlagsList, flag+"="+unhookPkg+"=")
				}
			}
			goFlags := strings.Join(goFlagsList, " ")

			for _, pkg := range pkgs {
				t.registerTest(hook+":"+pkg, "maymorestack="+hook,
					&goTest{
						timeout: 600 * time.Second,
						short:   true,
						env:     []string{"GOFLAGS=" + goFlags},
						pkg:     pkg,
					})
			}
		}
	}

	// On the builders only, test that a moved GOROOT still works.
	// Fails on iOS because CC_FOR_TARGET refers to clangwrap.sh
	// in the unmoved GOROOT.
	// Fails on Android and js/wasm with an exec format error.
	// Fails on plan9 with "cannot find GOROOT" (issue #21016).
	if os.Getenv("GO_BUILDER_NAME") != "" && goos != "android" && !t.iOS() && goos != "plan9" && goos != "js" {
		t.tests = append(t.tests, distTest{
			name:    "moved_goroot",
			heading: "moved GOROOT",
			fn: func(dt *distTest) error {
				t.runPending(dt)
				timelog("start", dt.name)
				defer timelog("end", dt.name)
				moved := goroot + "-moved"
				if err := os.Rename(goroot, moved); err != nil {
					if goos == "windows" {
						// Fails on Windows (with "Access is denied") if a process
						// or binary is in this directory. For instance, using all.bat
						// when run from c:\workdir\go\src fails here
						// if GO_BUILDER_NAME is set. Our builders invoke tests
						// a different way which happens to work when sharding
						// tests, but we should be tolerant of the non-sharded
						// all.bat case.
						log.Printf("skipping test on Windows")
						return nil
					}
					return err
				}

				// Run `go test fmt` in the moved GOROOT, without explicitly setting
				// GOROOT in the environment. The 'go' command should find itself.
				cmd := (&goTest{
					goroot: moved,
					pkg:    "fmt",
				}).command(t)
				unsetEnv(cmd, "GOROOT")
				unsetEnv(cmd, "GOCACHE") // TODO(bcmills): ...why‽
				err := cmd.Run()

				if rerr := os.Rename(moved, goroot); rerr != nil {
					fatalf("failed to restore GOROOT: %v", rerr)
				}
				return err
			},
		})
	}

	// Test that internal linking of standard packages does not
	// require libgcc. This ensures that we can install a Go
	// release on a system that does not have a C compiler
	// installed and still build Go programs (that don't use cgo).
	for _, pkg := range cgoPackages {
		if !t.internalLink() {
			break
		}

		// ARM libgcc may be Thumb, which internal linking does not support.
		if goarch == "arm" {
			break
		}

		// What matters is that the tests build and start up.
		// Skip expensive tests, especially x509 TestSystemRoots.
		run := "^Test[^CS]"
		if pkg == "net" {
			run = "TestTCPStress"
		}
		t.registerTest("nolibgcc:"+pkg, "Testing without libgcc.",
			&goTest{
				ldflags:  "-linkmode=internal -libgcc=none",
				runTests: run,
				pkg:      pkg,
			})
	}

	// Stub out following test on alpine until 54354 resolved.
	builderName := os.Getenv("GO_BUILDER_NAME")
	disablePIE := strings.HasSuffix(builderName, "-alpine")

	// Test internal linking of PIE binaries where it is supported.
	if t.internalLinkPIE() && !disablePIE {
		t.registerTest("pie_internal", "internal linking of -buildmode=pie",
			&goTest{
				timeout:   60 * time.Second,
				buildmode: "pie",
				ldflags:   "-linkmode=internal",
				env:       []string{"CGO_ENABLED=0"},
				pkg:       "reflect",
			})
		// Also test a cgo package.
		if t.cgoEnabled && t.internalLink() && !disablePIE {
			t.registerTest("pie_internal_cgo", "internal linking of -buildmode=pie",
				&goTest{
					timeout:   60 * time.Second,
					buildmode: "pie",
					ldflags:   "-linkmode=internal",
					pkg:       "os/user",
				})
		}
	}

	// sync tests
	if goos != "js" { // js doesn't support -cpu=10
		t.registerTest("sync_cpu", "sync -cpu=10",
			&goTest{
				timeout: 120 * time.Second,
				cpu:     "10",
				pkg:     "sync",
			})
	}

	if t.raceDetectorSupported() {
		t.registerRaceTests()
	}

	if t.cgoEnabled && !t.iOS() {
		// Disabled on iOS. golang.org/issue/15919
		t.registerTest("cgo_stdio", "", &goTest{dir: "../misc/cgo/stdio", timeout: 5 * time.Minute}, rtHostTest{})
		t.registerTest("cgo_life", "", &goTest{dir: "../misc/cgo/life", timeout: 5 * time.Minute}, rtHostTest{})
		if goos != "android" {
			t.registerTest("cgo_fortran", "", &goTest{dir: "../misc/cgo/fortran", timeout: 5 * time.Minute}, rtHostTest{})
		}
		if t.hasSwig() && goos != "android" {
			t.registerTest("swig_stdio", "", &goTest{dir: "../misc/swig/stdio"})
			if t.hasCxx() {
				t.registerTest("swig_callback", "", &goTest{dir: "../misc/swig/callback"})
				const cflags = "-flto -Wno-lto-type-mismatch -Wno-unknown-warning-option"
				t.registerTest("swig_callback_lto", "",
					&goTest{
						dir: "../misc/swig/callback",
						env: []string{
							"CGO_CFLAGS=" + cflags,
							"CGO_CXXFLAGS=" + cflags,
							"CGO_LDFLAGS=" + cflags,
						},
					})
			}
		}
	}
	if t.cgoEnabled {
		t.registerCgoTests()
	}

	// Don't run these tests with $GO_GCFLAGS because most of them
	// assume that they can run "go install" with no -gcflags and not
	// recompile the entire standard library. If make.bash ran with
	// special -gcflags, that's not true.
	if t.cgoEnabled && gogcflags == "" {
		t.registerTest("testgodefs", "", &goTest{dir: "../misc/cgo/testgodefs", timeout: 5 * time.Minute}, rtHostTest{})

		t.registerTest("testso", "", &goTest{dir: "../misc/cgo/testso", timeout: 600 * time.Second})
		t.registerTest("testsovar", "", &goTest{dir: "../misc/cgo/testsovar", timeout: 600 * time.Second})
		if t.supportedBuildmode("c-archive") {
			t.registerTest("testcarchive", "", &goTest{dir: "../misc/cgo/testcarchive", timeout: 5 * time.Minute}, rtHostTest{})
		}
		if t.supportedBuildmode("c-shared") {
			t.registerTest("testcshared", "", &goTest{dir: "../misc/cgo/testcshared", timeout: 5 * time.Minute}, rtHostTest{})
		}
		if t.supportedBuildmode("shared") {
			t.registerTest("testshared", "", &goTest{dir: "../misc/cgo/testshared", timeout: 600 * time.Second})
		}
		if t.supportedBuildmode("plugin") {
			t.registerTest("testplugin", "", &goTest{dir: "../misc/cgo/testplugin", timeout: 600 * time.Second})
		}
		if goos == "linux" || (goos == "freebsd" && goarch == "amd64") {
			// because Pdeathsig of syscall.SysProcAttr struct used in misc/cgo/testsanitizers is only
			// supported on Linux and FreeBSD.
			t.registerTest("testsanitizers", "", &goTest{dir: "../misc/cgo/testsanitizers", timeout: 5 * time.Minute}, rtHostTest{})
		}
		if t.hasBash() && goos != "android" && !t.iOS() && gohostos != "windows" {
			t.registerTest("cgo_errors", "", &goTest{dir: "../misc/cgo/errors", timeout: 5 * time.Minute}, rtHostTest{})
		}
	}

	if goos != "android" && !t.iOS() {
		// There are no tests in this directory, only benchmarks.
		// Check that the test binary builds.
		t.registerTest("bench_go1", "", &goTest{dir: "../test/bench/go1"})
	}
	if goos != "android" && !t.iOS() {
		// Only start multiple test dir shards on builders,
		// where they get distributed to multiple machines.
		// See issues 20141 and 31834.
		nShards := 1
		if os.Getenv("GO_BUILDER_NAME") != "" {
			nShards = 10
		}
		if n, err := strconv.Atoi(os.Getenv("GO_TEST_SHARDS")); err == nil {
			nShards = n
		}
		for shard := 0; shard < nShards; shard++ {
			shard := shard
			t.tests = append(t.tests, distTest{
				name:    fmt.Sprintf("test:%d_%d", shard, nShards),
				heading: "../test",
				fn:      func(dt *distTest) error { return t.testDirTest(dt, shard, nShards) },
			})
		}
	}
	// Only run the API check on fast development platforms.
	// Every platform checks the API on every GOOS/GOARCH/CGO_ENABLED combination anyway,
	// so we really only need to run this check once anywhere to get adequate coverage.
	// To help developers avoid trybot-only failures, we try to run on typical developer machines
	// which is darwin/linux/windows and amd64/arm64.
	if (goos == "darwin" || goos == "linux" || goos == "windows") && (goarch == "amd64" || goarch == "arm64") {
		t.tests = append(t.tests, distTest{
			name:    "api",
			heading: "API check",
			fn: func(dt *distTest) error {
				if t.compileOnly {
					t.addCmd(dt, "src", "go", "build", "-o", os.DevNull, filepath.Join(goroot, "src/cmd/api/run.go"))
					return nil
				}
				t.addCmd(dt, "src", "go", "run", filepath.Join(goroot, "src/cmd/api/run.go"))
				return nil
			},
		})
	}

	// Ensure that the toolchain can bootstrap itself.
	// This test adds another ~45s to all.bash if run sequentially, so run it only on the builders.
	if os.Getenv("GO_BUILDER_NAME") != "" && goos != "android" && !t.iOS() {
		t.registerTest("reboot", "", &goTest{dir: "../misc/reboot", timeout: 5 * time.Minute}, rtHostTest{})
	}
}

// isRegisteredTestName reports whether a test named testName has already
// been registered.
func (t *tester) isRegisteredTestName(testName string) bool {
	for _, tt := range t.tests {
		if tt.name == testName {
			return true
		}
	}
	return false
}

type registerTestOpt interface {
	isRegisterTestOpt()
}

// rtSequential is a registerTest option that causes the registered test to run
// sequentially.
type rtSequential struct{}

func (rtSequential) isRegisterTestOpt() {}

// rtPreFunc is a registerTest option that runs a pre function before running
// the test.
type rtPreFunc struct {
	pre func(*distTest) bool // Return false to skip the test
}

func (rtPreFunc) isRegisterTestOpt() {}

// rtHostTest is a registerTest option that indicates this is a host test that
// should be run using goTest.runHostTest. It implies rtSequential.
type rtHostTest struct{}

func (rtHostTest) isRegisterTestOpt() {}

// registerTest registers a test that runs the given goTest.
//
// If heading is "", it uses test.dir as the heading.
func (t *tester) registerTest(name, heading string, test *goTest, opts ...registerTestOpt) {
	seq := false
	hostTest := false
	var preFunc func(*distTest) bool
	for _, opt := range opts {
		switch opt := opt.(type) {
		case rtSequential:
			seq = true
		case rtPreFunc:
			preFunc = opt.pre
		case rtHostTest:
			seq, hostTest = true, true
		}
	}
	if t.isRegisteredTestName(name) {
		panic("duplicate registered test name " + name)
	}
	if heading == "" {
		heading = test.dir
	}
	t.tests = append(t.tests, distTest{
		name:    name,
		heading: heading,
		fn: func(dt *distTest) error {
			if preFunc != nil && !preFunc(dt) {
				return nil
			}
			if seq {
				t.runPending(dt)
				if hostTest {
					return test.runHostTest(t)
				}
				return test.run(t)
			}
			w := &work{
				dt:  dt,
				cmd: test.bgCommand(t),
			}
			t.worklist = append(t.worklist, w)
			return nil
		},
	})
}

// bgDirCmd constructs a Cmd intended to be run in the background as
// part of the worklist. The worklist runner will buffer its output
// and replay it sequentially. The command will be run in dir.
func (t *tester) bgDirCmd(dir, bin string, args ...string) *exec.Cmd {
	cmd := exec.Command(bin, args...)
	if filepath.IsAbs(dir) {
		setDir(cmd, dir)
	} else {
		setDir(cmd, filepath.Join(goroot, dir))
	}
	return cmd
}

// dirCmd constructs a Cmd intended to be run in the foreground.
// The command will be run in dir, and Stdout and Stderr will go to os.Stdout
// and os.Stderr.
func (t *tester) dirCmd(dir string, cmdline ...interface{}) *exec.Cmd {
	bin, args := flattenCmdline(cmdline)
	cmd := t.bgDirCmd(dir, bin, args...)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	if vflag > 1 {
		errprintf("%s\n", strings.Join(cmd.Args, " "))
	}
	return cmd
}

// flattenCmdline flattens a mixture of string and []string as single list
// and then interprets it as a command line: first element is binary, then args.
func flattenCmdline(cmdline []interface{}) (bin string, args []string) {
	var list []string
	for _, x := range cmdline {
		switch x := x.(type) {
		case string:
			list = append(list, x)
		case []string:
			list = append(list, x...)
		default:
			panic("invalid addCmd argument type: " + reflect.TypeOf(x).String())
		}
	}

	bin = list[0]
	if bin == "go" {
		bin = gorootBinGo
	}
	return bin, list[1:]
}

// addCmd adds a command to the worklist. Commands can be run in
// parallel, but their output will be buffered and replayed in the
// order they were added to worklist.
func (t *tester) addCmd(dt *distTest, dir string, cmdline ...interface{}) *exec.Cmd {
	bin, args := flattenCmdline(cmdline)
	w := &work{
		dt:  dt,
		cmd: t.bgDirCmd(dir, bin, args...),
	}
	t.worklist = append(t.worklist, w)
	return w.cmd
}

func (t *tester) iOS() bool {
	return goos == "ios"
}

func (t *tester) out(v string) {
	if t.banner == "" {
		return
	}
	fmt.Println("\n" + t.banner + v)
}

func (t *tester) extLink() bool {
	pair := gohostos + "-" + goarch
	switch pair {
	case "aix-ppc64",
		"android-arm", "android-arm64",
		"darwin-amd64", "darwin-arm64",
		"dragonfly-amd64",
		"freebsd-386", "freebsd-amd64", "freebsd-arm", "freebsd-riscv64",
		"linux-386", "linux-amd64", "linux-arm", "linux-arm64", "linux-loong64", "linux-ppc64le", "linux-mips64", "linux-mips64le", "linux-mips", "linux-mipsle", "linux-riscv64", "linux-s390x",
		"netbsd-386", "netbsd-amd64",
		"openbsd-386", "openbsd-amd64",
		"windows-386", "windows-amd64":
		return true
	}
	return false
}

func (t *tester) internalLink() bool {
	if gohostos == "dragonfly" {
		// linkmode=internal fails on dragonfly since errno is a TLS relocation.
		return false
	}
	if goos == "android" {
		return false
	}
	if goos == "ios" {
		return false
	}
	if goos == "windows" && goarch == "arm64" {
		return false
	}
	// Internally linking cgo is incomplete on some architectures.
	// https://golang.org/issue/10373
	// https://golang.org/issue/14449
	if goarch == "loong64" || goarch == "mips64" || goarch == "mips64le" || goarch == "mips" || goarch == "mipsle" || goarch == "riscv64" {
		return false
	}
	if goos == "aix" {
		// linkmode=internal isn't supported.
		return false
	}
	return true
}

func (t *tester) internalLinkPIE() bool {
	switch goos + "-" + goarch {
	case "darwin-amd64", "darwin-arm64",
		"linux-amd64", "linux-arm64", "linux-ppc64le",
		"android-arm64",
		"windows-amd64", "windows-386", "windows-arm":
		return true
	}
	return false
}

func (t *tester) supportedBuildmode(mode string) bool {
	pair := goos + "-" + goarch
	switch mode {
	case "c-archive":
		if !t.extLink() {
			return false
		}
		switch pair {
		case "aix-ppc64",
			"darwin-amd64", "darwin-arm64", "ios-arm64",
			"linux-amd64", "linux-386", "linux-ppc64le", "linux-riscv64", "linux-s390x",
			"freebsd-amd64",
			"windows-amd64", "windows-386":
			return true
		}
		return false
	case "c-shared":
		switch pair {
		case "linux-386", "linux-amd64", "linux-arm", "linux-arm64", "linux-ppc64le", "linux-riscv64", "linux-s390x",
			"darwin-amd64", "darwin-arm64",
			"freebsd-amd64",
			"android-arm", "android-arm64", "android-386",
			"windows-amd64", "windows-386", "windows-arm64":
			return true
		}
		return false
	case "shared":
		switch pair {
		case "linux-386", "linux-amd64", "linux-arm", "linux-arm64", "linux-ppc64le", "linux-s390x":
			return true
		}
		return false
	case "plugin":
		switch pair {
		case "linux-386", "linux-amd64", "linux-arm", "linux-arm64", "linux-s390x", "linux-ppc64le":
			return true
		case "darwin-amd64", "darwin-arm64":
			return true
		case "freebsd-amd64":
			return true
		}
		return false
	case "pie":
		switch pair {
		case "aix/ppc64",
			"linux-386", "linux-amd64", "linux-arm", "linux-arm64", "linux-ppc64le", "linux-riscv64", "linux-s390x",
			"android-amd64", "android-arm", "android-arm64", "android-386":
			return true
		case "darwin-amd64", "darwin-arm64":
			return true
		case "windows-amd64", "windows-386", "windows-arm":
			return true
		}
		return false

	default:
		fatalf("internal error: unknown buildmode %s", mode)
		return false
	}
}

func (t *tester) registerCgoTests() {
	cgoTest := func(name string, subdir, linkmode, buildmode string, opts ...registerTestOpt) *goTest {
		gt := &goTest{
			dir:       "../misc/cgo/" + subdir,
			buildmode: buildmode,
			ldflags:   "-linkmode=" + linkmode,
		}

		if linkmode == "internal" {
			gt.tags = append(gt.tags, "internal")
			if buildmode == "pie" {
				gt.tags = append(gt.tags, "internal_pie")
			}
		}
		if buildmode == "static" {
			// This isn't actually a Go buildmode, just a convenient way to tell
			// cgoTest we want static linking.
			gt.buildmode = ""
			if linkmode == "external" {
				gt.ldflags += ` -extldflags "-static -pthread"`
			} else if linkmode == "auto" {
				gt.env = append(gt.env, "CGO_LDFLAGS=-static -pthread")
			} else {
				panic("unknown linkmode with static build: " + linkmode)
			}
			gt.tags = append(gt.tags, "static")
		}

		t.registerTest("cgo:"+name, "../misc/cgo/test", gt, opts...)
		return gt
	}

	cgoTest("test-auto", "test", "auto", "")

	// Stub out various buildmode=pie tests  on alpine until 54354 resolved.
	builderName := os.Getenv("GO_BUILDER_NAME")
	disablePIE := strings.HasSuffix(builderName, "-alpine")

	if t.internalLink() {
		cgoTest("test-internal", "test", "internal", "")
	}

	os := gohostos
	p := gohostos + "/" + goarch
	switch {
	case os == "darwin", os == "windows":
		if !t.extLink() {
			break
		}
		// test linkmode=external, but __thread not supported, so skip testtls.
		cgoTest("test-external", "test", "external", "")

		gt := cgoTest("test-external-s", "test", "external", "")
		gt.ldflags += " -s"

		if t.supportedBuildmode("pie") && !disablePIE {
			cgoTest("test-auto-pie", "test", "auto", "pie")
			if t.internalLink() && t.internalLinkPIE() {
				cgoTest("test-internal-pie", "test", "internal", "pie")
			}
		}

	case os == "aix", os == "android", os == "dragonfly", os == "freebsd", os == "linux", os == "netbsd", os == "openbsd":
		gt := cgoTest("test-external-g0", "test", "external", "")
		gt.env = append(gt.env, "CGO_CFLAGS=-g0 -fdiagnostics-color")

		cgoTest("testtls-auto", "testtls", "auto", "")
		cgoTest("testtls-external", "testtls", "external", "")
		switch {
		case os == "aix":
			// no static linking
		case p == "freebsd/arm":
			// -fPIC compiled tls code will use __tls_get_addr instead
			// of __aeabi_read_tp, however, on FreeBSD/ARM, __tls_get_addr
			// is implemented in rtld-elf, so -fPIC isn't compatible with
			// static linking on FreeBSD/ARM with clang. (cgo depends on
			// -fPIC fundamentally.)
		default:
			// Check for static linking support
			var staticCheck rtPreFunc
			cmd := t.dirCmd("misc/cgo/test",
				compilerEnvLookup(defaultcc, goos, goarch), "-xc", "-o", "/dev/null", "-static", "-")
			cmd.Stdin = strings.NewReader("int main() {}")
			cmd.Stdout, cmd.Stderr = nil, nil // Discard output
			if err := cmd.Run(); err != nil {
				// Skip these tests
				staticCheck.pre = func(*distTest) bool {
					fmt.Println("No support for static linking found (lacks libc.a?), skip cgo static linking test.")
					return false
				}
			}

			// Static linking tests
			if goos != "android" && p != "netbsd/arm" {
				// TODO(#56629): Why does this fail on netbsd-arm?
				cgoTest("testtls-static", "testtls", "external", "static", staticCheck)
			}
			cgoTest("nocgo-auto", "nocgo", "auto", "", staticCheck)
			cgoTest("nocgo-external", "nocgo", "external", "", staticCheck)
			if goos != "android" {
				cgoTest("nocgo-static", "nocgo", "external", "static", staticCheck)
				cgoTest("test-static", "test", "external", "static", staticCheck)
				// -static in CGO_LDFLAGS triggers a different code path
				// than -static in -extldflags, so test both.
				// See issue #16651.
				if goarch != "loong64" {
					// TODO(#56623): Why does this fail on loong64?
					cgoTest("test-static-env", "test", "auto", "static", staticCheck)
				}
			}

			// PIE linking tests
			if t.supportedBuildmode("pie") && !disablePIE {
				cgoTest("test-pie", "test", "auto", "pie")
				if t.internalLink() && t.internalLinkPIE() {
					cgoTest("test-pie-internal", "test", "internal", "pie")
				}
				cgoTest("testtls-pie", "testtls", "auto", "pie")
				cgoTest("nocgo-pie", "nocgo", "auto", "pie")
			}
		}
	}
}

// run pending test commands, in parallel, emitting headers as appropriate.
// When finished, emit header for nextTest, which is going to run after the
// pending commands are done (and runPending returns).
// A test should call runPending if it wants to make sure that it is not
// running in parallel with earlier tests, or if it has some other reason
// for needing the earlier tests to be done.
func (t *tester) runPending(nextTest *distTest) {
	checkNotStale("go", "std")
	worklist := t.worklist
	t.worklist = nil
	for _, w := range worklist {
		w.start = make(chan bool)
		w.end = make(chan bool)
		go func(w *work) {
			if !<-w.start {
				timelog("skip", w.dt.name)
				w.out = []byte(fmt.Sprintf("skipped due to earlier error\n"))
			} else {
				timelog("start", w.dt.name)
				w.out, w.err = w.cmd.CombinedOutput()
				if w.err != nil {
					if isUnsupportedVMASize(w) {
						timelog("skip", w.dt.name)
						w.out = []byte(fmt.Sprintf("skipped due to unsupported VMA\n"))
						w.err = nil
					}
				}
			}
			timelog("end", w.dt.name)
			w.end <- true
		}(w)
	}

	started := 0
	ended := 0
	var last *distTest
	for ended < len(worklist) {
		for started < len(worklist) && started-ended < maxbg {
			w := worklist[started]
			started++
			w.start <- !t.failed || t.keepGoing
		}
		w := worklist[ended]
		dt := w.dt
		if dt.heading != "" && t.lastHeading != dt.heading {
			t.lastHeading = dt.heading
			t.out(dt.heading)
		}
		if dt != last {
			// Assumes all the entries for a single dt are in one worklist.
			last = w.dt
			if vflag > 0 {
				fmt.Printf("# go tool dist test -run=^%s$\n", dt.name)
			}
		}
		if vflag > 1 {
			errprintf("%s\n", strings.Join(w.cmd.Args, " "))
		}
		ended++
		<-w.end
		os.Stdout.Write(w.out)
		if w.err != nil {
			log.Printf("Failed: %v", w.err)
			t.failed = true
		}
		checkNotStale("go", "std")
	}
	if t.failed && !t.keepGoing {
		fatalf("FAILED")
	}

	if dt := nextTest; dt != nil {
		if dt.heading != "" && t.lastHeading != dt.heading {
			t.lastHeading = dt.heading
			t.out(dt.heading)
		}
		if vflag > 0 {
			fmt.Printf("# go tool dist test -run=^%s$\n", dt.name)
		}
	}
}

func (t *tester) hasBash() bool {
	switch gohostos {
	case "windows", "plan9":
		return false
	}
	return true
}

func (t *tester) hasCxx() bool {
	cxx, _ := exec.LookPath(compilerEnvLookup(defaultcxx, goos, goarch))
	return cxx != ""
}

func (t *tester) hasSwig() bool {
	swig, err := exec.LookPath("swig")
	if err != nil {
		return false
	}

	// Check that swig was installed with Go support by checking
	// that a go directory exists inside the swiglib directory.
	// See https://golang.org/issue/23469.
	output, err := exec.Command(swig, "-go", "-swiglib").Output()
	if err != nil {
		return false
	}
	swigDir := strings.TrimSpace(string(output))

	_, err = os.Stat(filepath.Join(swigDir, "go"))
	if err != nil {
		return false
	}

	// Check that swig has a new enough version.
	// See https://golang.org/issue/22858.
	out, err := exec.Command(swig, "-version").CombinedOutput()
	if err != nil {
		return false
	}

	re := regexp.MustCompile(`[vV]ersion +(\d+)([.]\d+)?([.]\d+)?`)
	matches := re.FindSubmatch(out)
	if matches == nil {
		// Can't find version number; hope for the best.
		return true
	}

	major, err := strconv.Atoi(string(matches[1]))
	if err != nil {
		// Can't find version number; hope for the best.
		return true
	}
	if major < 3 {
		return false
	}
	if major > 3 {
		// 4.0 or later
		return true
	}

	// We have SWIG version 3.x.
	if len(matches[2]) > 0 {
		minor, err := strconv.Atoi(string(matches[2][1:]))
		if err != nil {
			return true
		}
		if minor > 0 {
			// 3.1 or later
			return true
		}
	}

	// We have SWIG version 3.0.x.
	if len(matches[3]) > 0 {
		patch, err := strconv.Atoi(string(matches[3][1:]))
		if err != nil {
			return true
		}
		if patch < 6 {
			// Before 3.0.6.
			return false
		}
	}

	return true
}

func (t *tester) raceDetectorSupported() bool {
	if gohostos != goos {
		return false
	}
	if !t.cgoEnabled {
		return false
	}
	if !raceDetectorSupported(goos, goarch) {
		return false
	}
	// The race detector doesn't work on Alpine Linux:
	// golang.org/issue/14481
	if isAlpineLinux() {
		return false
	}
	// NetBSD support is unfinished.
	// golang.org/issue/26403
	if goos == "netbsd" {
		return false
	}
	return true
}

func isAlpineLinux() bool {
	if runtime.GOOS != "linux" {
		return false
	}
	fi, err := os.Lstat("/etc/alpine-release")
	return err == nil && fi.Mode().IsRegular()
}

func (t *tester) registerRaceTests() {
	hdr := "Testing race detector"
	t.registerTest("race:runtime/race", hdr,
		&goTest{
			race:     true,
			runTests: "Output",
			pkg:      "runtime/race",
		})
	t.registerTest("race", hdr,
		&goTest{
			race:     true,
			runTests: "TestParse|TestEcho|TestStdinCloseRace|TestClosedPipeRace|TestTypeRace|TestFdRace|TestFdReadRace|TestFileCloseRace",
			pkgs:     []string{"flag", "net", "os", "os/exec", "encoding/gob"},
		})
	// We don't want the following line, because it
	// slows down all.bash (by 10 seconds on my laptop).
	// The race builder should catch any error here, but doesn't.
	// TODO(iant): Figure out how to catch this.
	// t.registerTest("race:cmd/go", hdr, &goTest{race: true, runTests: "TestParallelTest", pkg: "cmd/go"})
	if t.cgoEnabled {
		// Building misc/cgo/test takes a long time.
		// There are already cgo-enabled packages being tested with the race detector.
		// We shouldn't need to redo all of misc/cgo/test too.
		// The race buildler will take care of this.
		// t.registerTest("race:misc/cgo/test", hdr, &goTest{dir: "../misc/cgo/test", race: true, env: []string{"GOTRACEBACK=2"}})
	}
	if t.extLink() {
		var oldWindows rtPreFunc
		if strings.HasPrefix(os.Getenv("GO_BUILDER_NAME"), "windows-amd64-2008") {
			oldWindows.pre = func(*distTest) bool {
				fmt.Println("skipping -race with external linkage on older windows builder, see https://github.com/golang/go/issues/56904 for details")
				return false
			}
		}
		// Test with external linking; see issue 9133.
		t.registerTest("race:external", hdr,
			&goTest{
				race:     true,
				ldflags:  "-linkmode=external",
				runTests: "TestParse|TestEcho|TestStdinCloseRace",
				pkgs:     []string{"flag", "os/exec"},
			}, oldWindows)
	}
}

var runtest struct {
	sync.Once
	exe string
	err error
}

func (t *tester) testDirTest(dt *distTest, shard, shards int) error {
	runtest.Do(func() {
		f, err := os.CreateTemp("", "runtest-*.exe") // named exe for Windows, but harmless elsewhere
		if err != nil {
			runtest.err = err
			return
		}
		f.Close()

		runtest.exe = f.Name()
		xatexit(func() {
			os.Remove(runtest.exe)
		})

		cmd := t.dirCmd("test", "go", "build", "-o", runtest.exe, "run.go")
		setEnv(cmd, "GOOS", gohostos)
		setEnv(cmd, "GOARCH", gohostarch)
		runtest.err = cmd.Run()
	})
	if runtest.err != nil {
		return runtest.err
	}
	if t.compileOnly {
		return nil
	}
	t.addCmd(dt, "test", runtest.exe,
		fmt.Sprintf("--shard=%d", shard),
		fmt.Sprintf("--shards=%d", shards),
	)
	return nil
}

// cgoPackages is the standard packages that use cgo.
var cgoPackages = []string{
	"net",
	"os/user",
}

var funcBenchmark = []byte("\nfunc Benchmark")

// packageHasBenchmarks reports whether pkg has benchmarks.
// On any error, it conservatively returns true.
//
// This exists just to eliminate work on the builders, since compiling
// a test in race mode just to discover it has no benchmarks costs a
// second or two per package, and this function returns false for
// about 100 packages.
func (t *tester) packageHasBenchmarks(pkg string) bool {
	pkgDir := filepath.Join(goroot, "src", pkg)
	d, err := os.Open(pkgDir)
	if err != nil {
		return true // conservatively
	}
	defer d.Close()
	names, err := d.Readdirnames(-1)
	if err != nil {
		return true // conservatively
	}
	for _, name := range names {
		if !strings.HasSuffix(name, "_test.go") {
			continue
		}
		slurp, err := os.ReadFile(filepath.Join(pkgDir, name))
		if err != nil {
			return true // conservatively
		}
		if bytes.Contains(slurp, funcBenchmark) {
			return true
		}
	}
	return false
}

// makeGOROOTUnwritable makes all $GOROOT files & directories non-writable to
// check that no tests accidentally write to $GOROOT.
func (t *tester) makeGOROOTUnwritable() (undo func()) {
	dir := os.Getenv("GOROOT")
	if dir == "" {
		panic("GOROOT not set")
	}

	type pathMode struct {
		path string
		mode os.FileMode
	}
	var dirs []pathMode // in lexical order

	undo = func() {
		for i := range dirs {
			os.Chmod(dirs[i].path, dirs[i].mode) // best effort
		}
	}

	gocache := os.Getenv("GOCACHE")
	if gocache == "" {
		panic("GOCACHE not set")
	}
	gocacheSubdir, _ := filepath.Rel(dir, gocache)

	filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
		if suffix := strings.TrimPrefix(path, dir+string(filepath.Separator)); suffix != "" {
			if suffix == gocacheSubdir {
				// Leave GOCACHE writable: we may need to write test binaries into it.
				return filepath.SkipDir
			}
			if suffix == ".git" {
				// Leave Git metadata in whatever state it was in. It may contain a lot
				// of files, and it is highly unlikely that a test will try to modify
				// anything within that directory.
				return filepath.SkipDir
			}
		}
		if err != nil {
			return nil
		}

		info, err := d.Info()
		if err != nil {
			return nil
		}

		mode := info.Mode()
		if mode&0222 != 0 && (mode.IsDir() || mode.IsRegular()) {
			dirs = append(dirs, pathMode{path, mode})
		}
		return nil
	})

	// Run over list backward to chmod children before parents.
	for i := len(dirs) - 1; i >= 0; i-- {
		err := os.Chmod(dirs[i].path, dirs[i].mode&^0222)
		if err != nil {
			dirs = dirs[i:] // Only undo what we did so far.
			undo()
			fatalf("failed to make GOROOT read-only: %v", err)
		}
	}

	return undo
}

// raceDetectorSupported is a copy of the function
// internal/platform.RaceDetectorSupported, which can't be used here
// because cmd/dist can not import internal packages during bootstrap.
// The race detector only supports 48-bit VMA on arm64. But we don't have
// a good solution to check VMA size(See https://golang.org/issue/29948)
// raceDetectorSupported will always return true for arm64. But race
// detector tests may abort on non 48-bit VMA configuration, the tests
// will be marked as "skipped" in this case.
func raceDetectorSupported(goos, goarch string) bool {
	switch goos {
	case "linux":
		return goarch == "amd64" || goarch == "ppc64le" || goarch == "arm64" || goarch == "s390x"
	case "darwin":
		return goarch == "amd64" || goarch == "arm64"
	case "freebsd", "netbsd", "openbsd", "windows":
		return goarch == "amd64"
	default:
		return false
	}
}

// isUnsupportedVMASize reports whether the failure is caused by an unsupported
// VMA for the race detector (for example, running the race detector on an
// arm64 machine configured with 39-bit VMA)
func isUnsupportedVMASize(w *work) bool {
	unsupportedVMA := []byte("unsupported VMA range")
	return w.dt.name == "race" && bytes.Contains(w.out, unsupportedVMA)
}

// isEnvSet reports whether the environment variable evar is
// set in the environment.
func isEnvSet(evar string) bool {
	evarEq := evar + "="
	for _, e := range os.Environ() {
		if strings.HasPrefix(e, evarEq) {
			return true
		}
	}
	return false
}


text:
<?php

require_once('config.class.php');

/**
* Class: myPDO
* Purpose: To simplify the PDO connection process and accuratly report database connection issues
* Notes:
*         1. Constructor takes a DbOptions class to accurately build a Database Source Name (DSN) and connect to a database
*        2. Sets the Statement_Class attribute to use our myPDOStatement rather than the built in PDOStatement
*        3. On error, a report is sent via dbError to the webadmin's email as defined in CoreClass.php (a redirect to /dbError.cc is also fired)
*/
class myPDO extends PDO
{
	protected static $instance = null;

	public function __construct()
	{
		try {
			parent::__construct( config::myPDO_getDSN(), config::myPDO_user, config::myPDO_pass, config::$myPDO_op );
			$this->setAttribute( PDO::ATTR_STATEMENT_CLASS, array('myPDOStatement') ); // Set Statement_Class
			$this->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
		} catch (PDOException $e) {
			if( $_SERVER['REQUEST_URI'] != '/db404' ) { // to be implemented
				die($e->getMessage());
				// This would be a good spot to dispatch a real error and redirect to /db404
			}
		}
	}
	protected function __clone()
    {
        //Me not like clones! Me smash clones!
    }
    public static function getInstance()
    {
    	if (!isset(static::$instance)) {
    		static::$instance = new static;
    	}
    	return static::$instance;
    }
}

/**
* Class: myPDOStatement
* Purpose: To extend the features of the default PDOStatement class
* Notes:
*        1. execute now allows us to pass multiple parameters and it will automatically wrap them as an array.
*                a. any single variable that is not an array will be wrapped as an array
*                b. default functionality is acceptable as well
*                b. Usage: $STH->execute($single_param) OR $STH->execute($first, $second, ...) OR $STH->execute(array($first, $second, ...))
*/
class myPDOStatement extends PDOStatement
{
	protected function __construct()
	{
		$this->setFetchMode( PDO::FETCH_ASSOC );
	}

	public function execute ( $bound_input_params = NULL )
	{
		$arr = func_get_args();
		$input_parameters = is_array($arr[0]) ? $arr[0] : $arr ;
		return parent::execute($input_parameters);
	}
}


text:
<?php

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 * Description of ValidAccessLevels
 *
 * @author Dan Kottke
 */
class ValidAccessLevels {
    const NO_ACCESS = 0;
    const BASIC_ACCESS = 1;
}

?>


text:
var c = console;
var startTime = new Date;
function mouseover(el){
    if (el.fireEvent) {
        el.fireEvent('on' + 'mouseover');
    } else {
        var evObj = document.createEvent('Events');
        evObj.initEvent('mouseover', true, false);
        el.dispatchEvent(evObj);
    }
}

function click(el){
    c.info("we click ");
    c.log (el);
    if(el){
        mouseover(el);
        if (el.fireEvent) {
            el.fireEvent('on' + 'click');
        } else {
            var evObj = document.createEvent('Events');
            evObj.initEvent('click', true, false);
            el.dispatchEvent(evObj);
        }
    }

}

function clickAd1234() {
    var ads = $(".adfu,.ad30,.adf").not(".mbx");
    if(ads.length>0){
        var node=ads[ads.length-1];
        var className=node.className;
        if(className.includes("adfu")||
           className.includes("ad30")||
           className.includes("adf")){
            if(node){
                click(node);
                var p = $(node).parent().parent().parent().parent();
                var redDot = p.find("img")[0];
                if(redDot){
                    click(redDot);
                    return;// exit. no dothing more
                }
            }
        }
    } else if($(".mbx.ad30").length>0){
        var adPrize = $(".mbx.ad30").find("a")[0];
        click(adPrize);
        return;// exit. no dothing more
    } else {
        closeWindow();
    }
}

var timeoutCloseViewAdWindow;
function closeWindow(){
    c.log ("handle close tab. ");
    if(timeoutCloseViewAdWindow==null){
         timeoutCloseViewAdWindow =
                setTimeout(function(){
                    window.onbeforeunload = null;
                    window.open('','_self').close();
                    window.opener='x';window.close();
                    timeoutCloseViewAdWindow = null;
                },1000);
    }

}

function performSuperman(){
    //Determine what tab is open
    var okImageOnViewAdScreen = $("img[src*='/n/ok.png']");

    if(okImageOnViewAdScreen.length>0){
        c.info("you are viewing ad");
        //Click close ad when ready
        if($("#o1").find("a").is(":visible")){
            click($("#o1").find("a")[0]);
        } else if($("#o1").find("a").is(":visible")||
          $("#nxt_bt_td").is(":visible")||
          $("#prm0").find(".orange").is(":visible")||
          new Date().getTime() - startTime > 60000){
            click($("#prm0").find(".orange")[0]);
            closeWindow();
        }
    } else {
        c.info("You must choose an ad");
        if(window.isActive ){
            clickAd1234();
            numOfRun++;
        }
    }
}

window.onfocus = function () {
    isActive = true;
};

window.onblur = function () {
    isActive = false;
};

//INIT
$(window).trigger('focus');
var numOfRun = 0; // using for main page.
setInterval(function () {
    console.log(window.isActive ? 'active' : 'inactive');
        if(numOfRun>=10){ //it should close and make a reset.
                window.opener='x';window.close();

            }
        performSuperman();
}, 3000);


text:
package javax.json;

import java.io.InputStream;
import java.io.Reader;
import java.nio.charset.Charset;
import java.util.Map;
import javax.json.JsonReader;

public interface JsonReaderFactory
{
    JsonReader createReader(InputStream p0);
    JsonReader createReader(InputStream p0, Charset p1);
    JsonReader createReader(Reader p0);
    Map<String, ? extends Object> getConfigInUse();
}


text:
<?php
/**
 * Created by PhpStorm.
 * User: Keith
 * Date: 4/8/2017
 * Time: 6:32 PM
 */

namespace Kicken\JSONRPC\Exception;

class JSONRPCException extends \RuntimeException {
    protected $data;

    /**
     * JSONRPCException constructor.
     *
     * @param string $message Brief message describing the error
     * @param int $code Error code value
     * @param mixed $data Extra data or details related to this error
     */
    public function __construct($message = "", $code = 0, $data = null){
        parent::__construct($message, $code);
        $this->data = $data;
    }

    public function getData(){
        return $this->data;
    }
}


text:
describe 'a suggestion' do
  let(:term_opts) { { width: 200 } }
  let(:long_command) { "echo #{'a' * 100}" }

  around do |example|
    with_history(long_command) { example.run }
  end

  it 'is provided for any buffer length' do
    session.send_string(long_command[0...-1])
    wait_for { session.content }.to eq(long_command)
  end

  context 'when ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE is specified' do
    let(:buffer_max_size) { 10 }
    let(:options) { ["ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE=#{buffer_max_size}"] }

    it 'is provided when the buffer is shorter than the specified length' do
      session.send_string(long_command[0...(buffer_max_size - 1)])
      wait_for { session.content }.to eq(long_command)
    end

    it 'is provided when the buffer is equal to the specified length' do
      session.send_string(long_command[0...(buffer_max_size)])
      wait_for { session.content }.to eq(long_command)
    end

    it 'is not provided when the buffer is longer than the specified length'
  end
end


text:
module RequestSpecHelper

  def stub_ok_request(token, status = 200)
    stub_request(:get, "https://sandbox-nvp.billsafe.de/V209?Order_currencyCode=EUR&format=json&method=PrepareOrder").
        with(:headers => {'Accept'=>'*/*', 'User-Agent'=>'Ruby'}).
        to_return(:status => 200, :body => '{
          "ack":"OK",
          "status":"ACCEPTED",
          "transactionId":"987654321",
          "token":"' + token + '"}', :headers => {})
  end

  def stub_error_request()
    stub_request(:get, "https://sandbox-nvp.billsafe.de/V209?Order_currencyCode=EUR&format=json&method=PrepareOrder").
        with(:headers => {'Accept'=>'*/*', 'User-Agent'=>'Ruby'}).
        to_return(:status => 200, :body => '{
            "ack":"ERROR",
            "errorList":[
              { "code":"123", "message":"Fehler 1" },
              { "code":"456", "message":"Fehler 2"}
            ]
        }', :headers => {})
  end

end


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<TITLE
>pg_buffercache</TITLE
><META
NAME="GENERATOR"
CONTENT="Modular DocBook HTML Stylesheet Version 1.79"><LINK
REV="MADE"
HREF="mailto:pgsql-docs@postgresql.org"><LINK
REL="HOME"
TITLE="PostgreSQL 9.6.2 Documentation"
HREF="index.html"><LINK
REL="UP"
TITLE="Additional Supplied Modules"
HREF="contrib.html"><LINK
REL="PREVIOUS"
TITLE="passwordcheck"
HREF="passwordcheck.html"><LINK
REL="NEXT"
TITLE="pgcrypto"
HREF="pgcrypto.html"><LINK
REL="STYLESHEET"
TYPE="text/css"
HREF="stylesheet.css"><META
HTTP-EQUIV="Content-Type"
CONTENT="text/html; charset=ISO-8859-1"><META
NAME="creation"
CONTENT="2017-02-06T21:56:32">

PostgreSQL 9.6.2 Documentation

Prev	Up	Appendix F. Additional Supplied Modules	Next

F.24. pg_buffercache

  The <TT
CLASS="FILENAME"
>pg_buffercache</TT
> module provides a means for
  examining what's happening in the shared buffer cache in real time.

  The module provides a C function pg_buffercache_pages
  that returns a set of records, plus a view
  <TT
CLASS="STRUCTNAME"
>pg_buffercache</TT
> that wraps the function for
  convenient use.

  By default public access is revoked from both of these, just in case there
  are security issues lurking.

F.24.1. The <TT
CLASS="STRUCTNAME"
>pg_buffercache</TT
> View

   The definitions of the columns exposed by the view are shown in Table F-16.

Table F-16. <TT
CLASS="STRUCTNAME"
>pg_buffercache</TT
> Columns

<COL><COL><COL><COL>

Name	Type	References	Description

<TT
CLASS="STRUCTFIELD"
>bufferid</TT
>	<TT
CLASS="TYPE"
>integer</TT
>	 	ID, in the range 1..<TT
CLASS="VARNAME"
>shared_buffers</TT
>

<TT
CLASS="STRUCTFIELD"
>relfilenode</TT
>	<TT
CLASS="TYPE"
>oid</TT
>	<TT
CLASS="LITERAL"
>pg_class.relfilenode</TT
>	Filenode number of the relation

<TT
CLASS="STRUCTFIELD"
>reltablespace</TT
>	<TT
CLASS="TYPE"
>oid</TT
>	<TT
CLASS="LITERAL"
>pg_tablespace.oid</TT
>	Tablespace OID of the relation

<TT
CLASS="STRUCTFIELD"
>reldatabase</TT
>	<TT
CLASS="TYPE"
>oid</TT
>	<TT
CLASS="LITERAL"
>pg_database.oid</TT
>	Database OID of the relation

<TT
CLASS="STRUCTFIELD"
>relforknumber</TT
>	<TT
CLASS="TYPE"
>smallint</TT
>	 	Fork number within the relation;  see
      <TT
CLASS="FILENAME"
>include/common/relpath.h</TT
>

<TT
CLASS="STRUCTFIELD"
>relblocknumber</TT
>	<TT
CLASS="TYPE"
>bigint</TT
>	 	Page number within the relation

<TT
CLASS="STRUCTFIELD"
>isdirty</TT
>	<TT
CLASS="TYPE"
>boolean</TT
>	 	Is the page dirty?

<TT
CLASS="STRUCTFIELD"
>usagecount</TT
>	<TT
CLASS="TYPE"
>smallint</TT
>	 	Clock-sweep access count

<TT
CLASS="STRUCTFIELD"
>pinning_backends</TT
>	<TT
CLASS="TYPE"
>integer</TT
>	 	Number of backends pinning this buffer

   There is one row for each buffer in the shared cache. Unused buffers are
   shown with all fields null except <TT
CLASS="STRUCTFIELD"
>bufferid</TT
>.  Shared system
   catalogs are shown as belonging to database zero.

   Because the cache is shared by all the databases, there will normally be
   pages from relations not belonging to the current database.  This means
   that there may not be matching join rows in <TT
CLASS="STRUCTNAME"
>pg_class</TT
> for
   some rows, or that there could even be incorrect joins.  If you are
   trying to join against <TT
CLASS="STRUCTNAME"
>pg_class</TT
>, it's a good idea to
   restrict the join to rows having <TT
CLASS="STRUCTFIELD"
>reldatabase</TT
> equal to
   the current database's OID or zero.

   When the <TT
CLASS="STRUCTNAME"
>pg_buffercache</TT
> view is accessed, internal buffer
   manager locks are taken for long enough to copy all the buffer state
   data that the view will display.
   This ensures that the view produces a consistent set of results, while not
   blocking normal buffer activity longer than necessary.  Nonetheless there
   could be some impact on database performance if this view is read often.

F.24.2. Sample Output

regression=# SELECT c.relname, count(*) AS buffers
             FROM pg_buffercache b INNER JOIN pg_class c
             ON b.relfilenode = pg_relation_filenode(c.oid) AND
                b.reldatabase IN (0, (SELECT oid FROM pg_database
                                      WHERE datname = current_database()))
             GROUP BY c.relname
             ORDER BY 2 DESC
             LIMIT 10;

             relname             | buffers
---------------------------------+---------
 tenk2                           |     345
 tenk1                           |     141
 pg_proc                         |      46
 pg_class                        |      45
 pg_attribute                    |      43
 pg_class_relname_nsp_index      |      30
 pg_proc_proname_args_nsp_index  |      28
 pg_attribute_relid_attnam_index |      26
 pg_depend                       |      22
 pg_depend_reference_index       |      20
(10 rows)

F.24.3. Authors

   Mark Kirkwood <markir@paradise.net.nz>

   Design suggestions: Neil Conway <neilc@samurai.com>

   Debugging advice: Tom Lane <tgl@sss.pgh.pa.us>

Prev	Home	Next

passwordcheck	Up	pgcrypto