text:
using Gallio.Common;
using Gallio.Properties;

namespace Gallio.Model.Tree
{
    /// <summary>
    /// The root test in the test tree.
    /// </summary>
    public class RootTest : Test
    {
        /// <summary>
        /// Gets the root test name.
        /// </summary>
        public static readonly string RootTestName = Resources.RootTest_RootTestName;

        /// <summary>
        /// Creates the root test.
        /// </summary>
        public RootTest()
            : base(RootTestName, null)
        {
            Kind = TestKinds.Root;
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
package textbox

import (
	"fmt"

	"github.com/kasworld/go-sdl2/sdl"
	"github.com/kasworld/go-sdlgui"
	"github.com/kasworld/htmlcolors"
)

type TextBoxControl struct {
	*sdlgui.Control
	font      *sdlgui.Font
	bg        htmlcolors.RGBA
	fg        htmlcolors.RGBA
	texts     []string
	linecount int
}

func New(x, y, z int, wx, wy int, linecount int, font *sdlgui.Font) *TextBoxControl {
	tc := TextBoxControl{
		sdlgui.NewControl(x, y, z, wx, wy),
		font,
		htmlcolors.Black.ToRGBA(),
		htmlcolors.White.ToRGBA(),
		make([]string, 0),
		linecount,
	}
	tc.BorderSize = 2
	tc.BorderType = 1
	return &tc
}
func (tc *TextBoxControl) DrawSurface() {
	if !tc.ContentsChanged {
		return
	}
	tc.ContentsChanged = false

	tc.Rend.SetDrawColor(tc.bg[0], tc.bg[1], tc.bg[2], tc.bg[3])
	tc.Rend.Clear()
	st := 0
	if len(tc.texts) > tc.linecount {
		st = len(tc.texts) - tc.linecount
	}
	for i, text := range tc.texts[st:] {
		surface, srcRect := tc.font.MakeSurface(tc.fg, text)
		defer surface.Free()
		dstRect := sdl.Rect{
			tc.BorderSize, int32(i*int(tc.H)/tc.linecount) - tc.BorderSize,
			srcRect.W*int32(tc.H/tc.linecount)/srcRect.H - tc.BorderSize, int32(tc.H / tc.linecount),
		}
		if dstRect.W < int32(tc.W) {
			surface.Blit(&srcRect, tc.Suf, &dstRect)
		} else {
			dstRect.W = int32(tc.W)
			surface.BlitScaled(&srcRect, tc.Suf, &dstRect)
		}
	}
	tc.Rend.Present()
	tc.Win.AddUpdateControl(tc)
}
func (tc *TextBoxControl) MouseOver(x, y int, btnstate uint32) {
}
func (tc *TextBoxControl) MouseButton(x, y int, btnnum uint8, btnstate uint8) {
	tc.bg, tc.fg = tc.fg, tc.bg
	tc.ContentsChanged = true
	tc.DrawSurface()
}
func (tc *TextBoxControl) MouseWheel(x, y int, dx int32, dy int32, btnstate uint32) {
}
func (tc *TextBoxControl) SetBG(bg htmlcolors.RGBA) {
	if bg == tc.bg {
		return
	}
	tc.ContentsChanged = true
	tc.bg = bg
}
func (tc *TextBoxControl) SetFG(fg htmlcolors.RGBA) {
	if fg == tc.fg {
		return
	}
	tc.ContentsChanged = true
	tc.fg = fg
}
func (tc *TextBoxControl) AddText(format string, a ...interface{}) {
	tc.ContentsChanged = true
	text := fmt.Sprintf(format, a...)
	tc.texts = append(tc.texts, text)
}
func (tc *TextBoxControl) SetTexts(texts []string) {
	tc.ContentsChanged = true
	tc.texts = texts
}


text:
<meta charset='utf-8'/>
<script src="/kissy/tools/third-party/jquery.js"></script>
<script>
    $(function () {
        $.io({
            url: "http://"+location.hostname+":9999/kissy/src/" +
                    "io/tests/jsonp.jss",
            dataType: 'jsonp',
            //forceScript:true,
            success: function () {
                var args = $.makeArray(arguments);
                debugger
                console.log(1);
            },
            error: function () {
                var args = $.makeArray(arguments);
                debugger
                console.log(2);
            },
            complete: function () {
                var args = $.makeArray(arguments);
                debugger
                console.log(3);
            }
        });
    });
</script>


text:
package ilargia.egdx.logicbricks.component.game;

import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import ilargia.entitas.api.IComponent;
import ilargia.entitas.codeGenerator.Component;
import ilargia.egdx.logicbricks.data.Bounds;

@Component(pools = {"Game"})
public class TextureView implements IComponent {
    public TextureRegion texture;
    public Bounds bounds;
    public boolean flipX;
    public boolean flipY;
    public float opacity;
    public int layer;
    public Color tint;

    public TextureView(TextureRegion texture, Bounds bounds, boolean flipX, boolean flipY,
                       float opacity, int layer, Color tint) {
        this.texture = texture;
        this.bounds = bounds;
        this.flipX = flipX;
        this.flipY = flipY;
        this.opacity = opacity;
        this.layer = layer;
        this.tint = tint;
    }
}


text:
<?xml version="1.0" ?>

<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/services http://symfony.com/schema/dic/services/services-1.0.xsd">

    <services>

        <service id="fos_rest.view_response_listener" class="FOS\RestBundle\EventListener\ViewResponseListener">
            <tag name="kernel.event_subscriber" />
            <argument type="service" id="fos_rest.view_handler" />
            <argument /> <!-- force view -->
        </service>

    </services>
</container>


text:
package br.ufc.mdcc.mpos.model;

import org.json.JSONException;
import org.json.JSONObject;

/**
 * @author Philipp
 */
public final class Device {

	private String mobileId;
	private String deviceName;
	private String carrier;
	private String longitude;
	private String latitude;

	public final String getMobileId() {
		return mobileId;
	}

	public final void setMobileId(String mobileId) {
		this.mobileId = mobileId;
	}

	public final String getDeviceName() {
		return deviceName;
	}

	public final void setDeviceName(String deviceName) {
		this.deviceName = deviceName;
	}

	public void setCarrier(String carrier) {
		this.carrier = carrier;
	}

	public String getCarrier() {
		return carrier;
	}

	public final String getLongitude() {
		return longitude;
	}

	public final void setLongitude(String longitude) {
		this.longitude = longitude;
	}

	public final String getLatitude() {
		return latitude;
	}

	public final void setLatitude(String latitude) {
		this.latitude = latitude;
	}

	public JSONObject toJSON() throws JSONException {
		JSONObject object = new JSONObject();

		object.put("mobileId", mobileId);
		object.put("deviceName", deviceName);
		object.put("carrier", carrier);
		object.put("lat", latitude);
		object.put("lon", longitude);

		return object;
	}

	public String toString() {
		try {
			return toJSON().toString();
		} catch (JSONException e) {
			return null;
		}
	}
}


text:
<?php

declare(strict_types=1);

namespace Doctrine\Common\Collections\Expr;

use RuntimeException;

use function count;

/**
 * Expression of Expressions combined by AND or OR operation.
 */
class CompositeExpression implements Expression
{
    final public const TYPE_AND = 'AND';
    final public const TYPE_OR  = 'OR';
    final public const TYPE_NOT = 'NOT';

    /** @var list<Expression> */
    private array $expressions = [];

    /**
     * @param Expression[] $expressions
     *
     * @throws RuntimeException
     */
    public function __construct(private readonly string $type, array $expressions)
    {
        foreach ($expressions as $expr) {
            if ($expr instanceof Value) {
                throw new RuntimeException('Values are not supported expressions as children of and/or expressions.');
            }

            if (! ($expr instanceof Expression)) {
                throw new RuntimeException('No expression given to CompositeExpression.');
            }

            $this->expressions[] = $expr;
        }

        if ($type === self::TYPE_NOT && count($this->expressions) !== 1) {
            throw new RuntimeException('Not expression only allows one expression as child.');
        }
    }

    /**
     * Returns the list of expressions nested in this composite.
     *
     * @return list<Expression>
     */
    public function getExpressionList()
    {
        return $this->expressions;
    }

    /** @return string */
    public function getType()
    {
        return $this->type;
    }

    /**
     * {@inheritDoc}
     */
    public function visit(ExpressionVisitor $visitor)
    {
        return $visitor->walkCompositeExpression($this);
    }
}


text:
import { t } from '../../test/index';
import { Config } from './config';
import { ViewBroker } from './view-broker';

export function main() {
  t.describe('utilities: ViewBroker', () => {
    t.be(() => Config.RESET());

    t.it('TEMPLATE_URL: web', () => {
      Config.PLATFORM_TARGET = Config.PLATFORMS.WEB;
      t.e(ViewBroker.TEMPLATE_URL('./app/components/home/home.html')).toBe('./app/components/home/home.html');
    });
    t.it('TEMPLATE_URL: mobile_native', () => {
      Config.PLATFORM_TARGET = Config.PLATFORMS.MOBILE_NATIVE;
      t.e(ViewBroker.TEMPLATE_URL('./app/components/home/home.html')).toBe('./app/components/home/home.tns.html');
    });
    t.it('TEMPLATE_URL: mobile_hybrid', () => {
      Config.PLATFORM_TARGET = Config.PLATFORMS.MOBILE_HYBRID;
      t.e(ViewBroker.TEMPLATE_URL('./app/components/home/home.html')).toBe('./app/components/home/home.html');
    });
    t.it('TEMPLATE_URL: desktop', () => {
      Config.PLATFORM_TARGET = Config.PLATFORMS.DESKTOP;
      t.e(ViewBroker.TEMPLATE_URL('./app/components/home/home.html')).toBe('./app/components/home/home.html');
    });
  });
}


text:
FOUNDATION_EXPORT double PusherSwiftVersionNumber;
FOUNDATION_EXPORT const unsigned char PusherSwiftVersionString[];


text:
namespace OneCog.Io.LightwaveRf
{
    public interface IDevice
    {
        uint Room { get; }
        uint Device { get; }
    }
}


text:
package org.zstack.header.identity;

import java.util.List;

/**
 * Created by mingjian.deng on 17/3/2.
 */
public interface AddtionalResourceTypeExtensionPoint {
    List<String> getAddtionalResourceType();
}


text:
function getURLParameter(name) {
  return decodeURIComponent((new RegExp('[?|&]' + name + '=' + '([^&;]+?)(&|#|;|$)').exec(location.search) || [null, ''])[1].replace(/\+/g, '%20')) || null;
}

// Returns a random integer between min (included) and max (included)
// Using Math.round() will give you a non-uniform distribution!
// Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random
function getRandomIntInclusive(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

//
// This function is automatically generated by the Firebase web console
// Please change this function accordingly
// Reference: https://console.firebase.google.com
//

function initalizeFirebase() {

  // Initialize Firebase
  var config = {
    apiKey: "AIzaSyDWBsNtdNcMzTLtvKEiqSHlx3eZu0RsFtY",
    authDomain: "swimcapboys.firebaseapp.com",
    databaseURL: "https://swimcapboys.firebaseio.com",
    storageBucket: "swimcapboys.appspot.com",
    messagingSenderId: "775129663322"
  };
  firebase.initializeApp(config);

}

//
// User-defined function - Useful for retrieving an object once, without 3-way sync
// For 3-way sync, use $firebaseObject or $firebaseArray provided by AngularFire
//

function retrieveOnceFirebase(firebase, refPath, callbackFunc) {
	firebase.database().ref(refPath).once("value").then(callbackFunc);
}


text:
package edu.duke.catrip.cae.domain.breast;

import junit.framework.TestCase;
import junit.framework.TestResult;
import junit.framework.TestSuite;
import junit.textui.TestRunner;
import edu.duke.catrip.cae.domain.general.CAEDataGenerator;

public class OtherBreastCancerHistopathologicGradeInsertTest extends TestCase {

	  private static int maxrecs = 500;
	  private static String inFile1 = "data\\OthHisPathGradeSystemNam.txt";
	  private static String newFile1 = "data\\OthHisPathGradeSystemNamV2.txt";
	  private static String inFile2 = "data\\OthHisPathGradeMitoticCnt.txt";

	  public String[] dataarr1 = new String[1000];
	  public String[] dataarr2 = new String[1000];

	  CAEDataGenerator dg = new CAEDataGenerator();

	  public OtherBreastCancerHistopathologicGradeInsertTest(String sTestName) {
	      super(sTestName);
	  }

	   //test reading data files into an array and insert into db
		public void testRead_Insert() throws Exception {

			final boolean DEBUG = true;

			if (DEBUG) System.out.println("Inside testReadFile()...");

			//System Name
	 		dg.buildDataFile(maxrecs,inFile1,newFile1);
			dataarr1=dg.ReadFile(maxrecs,newFile1);

			if (DEBUG) {
				int arrsize=dataarr1.length;
		        //print fields
		        for (int row=0; row<arrsize; row++) {
	       	    	System.out.println("\t\t\tOthSurgProc: " + dataarr1[row]);
		       	}
			}

			if (DEBUG) System.out.println("\tBack Inside testReadFile()");

			//MitoticCnt
			dg.buildDataFile(inFile2,1,20);
			dataarr2=dg.ReadFile(maxrecs,inFile2);

			if (DEBUG) {
				int arrsize=dataarr2.length;
		        //print fields
		        for (int row=0; row<arrsize; row++) {
	       	    	System.out.println("\t\t\tMC Location: " + dataarr2[row]);
		       	}
			}

			if (DEBUG) System.out.println("\tBack Inside testReadFile()");

			dg.buildOtherBreastCancerHistopathologicGrade(maxrecs,dataarr1,dataarr2);

			if (DEBUG) System.out.println("\tEnd Of testReadFile...");

		}

		public static void main(String[] args) throws Exception
		{
			System.out.println("\tInside main...");
			TestRunner runner = new TestRunner();
			TestResult result = runner.doRun(new TestSuite(OtherBreastCancerHistopathologicGradeInsertTest.class));
			System.exit(result.errorCount() + result.failureCount());
		}
}


text:
using testing::Invoke;
using testing::NiceMock;
using testing::_;

namespace media {
namespace {
template <typename ReturnType>
void RunAndSignalTask(base::WaitableEvent* event,
                      ReturnType* return_value,
                      const base::Callback<ReturnType(void)>& cb) {
  *return_value = cb.Run();
  event->Signal();
}

void WaitUntilRestarted(base::WaitableEvent* about_to_wait_event,
                        base::WaitableEvent* wait_event) {
  // Notify somebody that we've started.
  if (about_to_wait_event)
    about_to_wait_event->Signal();
  wait_event->Wait();
}

void SignalImmediately(base::WaitableEvent* event) {
  event->Signal();
}
}

class MockTickClock : public base::TickClock {
 public:
  MockTickClock() {
    // Don't start with the null time.
    Advance(1000);
  }
  ~MockTickClock() override{};
  base::TimeTicks NowTicks() override {
    base::AutoLock auto_lock(lock_);
    return now_;
  }

  // Handy utility.
  void Advance(int msec) {
    base::AutoLock auto_lock(lock_);
    now_ += base::TimeDelta::FromMilliseconds(msec);
  }

 private:
  base::Lock lock_;
  base::TimeTicks now_;
};

class MockClient : public AVDACodecAllocatorClient {
 public:
  MOCK_METHOD1(OnSurfaceAvailable, void(bool success));
  MOCK_METHOD0(OnSurfaceDestroyed, void());

  // Gmock doesn't let us mock methods taking move-only types.
  MOCK_METHOD1(OnCodecConfiguredMock, void(VideoCodecBridge* media_codec));
  void OnCodecConfigured(
      std::unique_ptr<VideoCodecBridge> media_codec) override {
    OnCodecConfiguredMock(media_codec.get());
  }
};

class AVDACodecAllocatorTest : public testing::Test {
 public:
  AVDACodecAllocatorTest() : allocator_thread_("AllocatorThread") {}
  ~AVDACodecAllocatorTest() override {}

 protected:
  void SetUp() override {
    // Start the main thread for the allocator.  This would normally be the GPU
    // main thread.
    ASSERT_TRUE(allocator_thread_.Start());

    // AVDACodecAllocator likes to post tasks to the current thread.

    test_information_.reset(new AVDACodecAllocator::TestInformation());
    test_information_->tick_clock_.reset(new MockTickClock());
    test_information_->stop_event_.reset(new base::WaitableEvent(
        base::WaitableEvent::ResetPolicy::AUTOMATIC,
        base::WaitableEvent::InitialState::NOT_SIGNALED));

    // Allocate the allocator on the appropriate thread.
    allocator_ = PostAndWait(
        FROM_HERE, base::Bind(
                       [](AVDACodecAllocator::TestInformation* test_info) {
                         return new AVDACodecAllocator(test_info);
                       },
                       test_information_.get()));
    allocator2_ = new AVDACodecAllocator(test_information_.get());

    // All threads should be stopped
    ASSERT_FALSE(IsThreadRunning(TaskType::AUTO_CODEC));
    ASSERT_FALSE(IsThreadRunning(TaskType::SW_CODEC));

    // Register an AVDA instance to start the allocator's threads.
    ASSERT_TRUE(StartThread(avda1_));

    // Assert that at least the AUTO_CODEC thread is started.  The other might
    // not be.
    ASSERT_TRUE(IsThreadRunning(TaskType::AUTO_CODEC));
    ASSERT_EQ(TaskType::AUTO_CODEC, TaskTypeForAllocation());
  }

  void TearDown() override {
    // Don't leave any threads hung, or this will hang too.
    // It would be nice if we could let a unique ptr handle this, but the
    // destructor is private.  We also have to destroy it on the right thread.
    PostAndWait(FROM_HERE, base::Bind(
                               [](AVDACodecAllocator* allocator) {
                                 delete allocator;
                                 return true;
                               },
                               allocator_));

    allocator_thread_.Stop();
    delete allocator2_;
  }

 protected:

  // Start / stop the threads for |avda| on the right thread.
  bool StartThread(AVDACodecAllocatorClient* avda) {
    return PostAndWait(FROM_HERE, base::Bind(
                                      [](AVDACodecAllocator* allocator,
                                         AVDACodecAllocatorClient* avda) {
                                        return allocator->StartThread(avda);
                                      },
                                      allocator_, avda));
  }

  void StopThread(AVDACodecAllocatorClient* avda) {
    // Note that we also wait for the stop event, so that we know that the
    // stop has completed.  It's async with respect to the allocator thread.
    PostAndWait(FROM_HERE, base::Bind(
                               [](AVDACodecAllocator* allocator,
                                  AVDACodecAllocatorClient* avda) {
                                 allocator->StopThread(avda);
                                 return true;
                               },
                               allocator_, avda));
    // Note that we don't do this on the allocator thread, since that's the
    // thread that will signal it.
    test_information_->stop_event_->Wait();
  }

  // Return the running state of |task_type|, doing the necessary thread hops.
  bool IsThreadRunning(TaskType task_type) {
    return PostAndWait(
        FROM_HERE,
        base::Bind(
            [](AVDACodecAllocator* allocator, TaskType task_type) {
              return allocator->GetThreadForTesting(task_type).IsRunning();
            },
            allocator_, task_type));
  }

  TaskType TaskTypeForAllocation() {
    return PostAndWait(FROM_HERE,
                       base::Bind(&AVDACodecAllocator::TaskTypeForAllocation,
                                  base::Unretained(allocator_)));
  }

  scoped_refptr<base::SingleThreadTaskRunner> TaskRunnerFor(
      TaskType task_type) {
    return PostAndWait(FROM_HERE,
                       base::Bind(&AVDACodecAllocator::TaskRunnerFor,
                                  base::Unretained(allocator_), task_type));
  }

  // Post |cb| to the allocator thread, and wait for a response.  Note that we
  // don't have a specialization for void, and void won't work as written.  So,
  // be sure to return something.
  template <typename ReturnType>
  ReturnType PostAndWait(const tracked_objects::Location& from_here,
                         const base::Callback<ReturnType(void)>& cb) {
    base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
                              base::WaitableEvent::InitialState::NOT_SIGNALED);
    ReturnType return_value = ReturnType();
    allocator_thread_.task_runner()->PostTask(
        from_here,
        base::Bind(&RunAndSignalTask<ReturnType>, &event, &return_value, cb));
    event.Wait();
    return return_value;
  }

  base::Thread allocator_thread_;

  // Test info that we provide to the codec allocator.
  std::unique_ptr<AVDACodecAllocator::TestInformation> test_information_;

  // Allocators that we own. The first is intialized to be used on the allocator
  // thread and the second one is initialized on the test thread. Each test
  // should only be using one of the two. They are not unique_ptrs because the
  // destructor is private and they need to be destructed on the right thread.
  AVDACodecAllocator* allocator_ = nullptr;
  AVDACodecAllocator* allocator2_ = nullptr;

  NiceMock<MockClient> client1_, client2_, client3_;
  NiceMock<MockClient>* avda1_ = &client1_;
  NiceMock<MockClient>* avda2_ = &client2_;
  NiceMock<MockClient>* avda3_ = &client3_;
};

TEST_F(AVDACodecAllocatorTest, TestMultiInstance) {
  // Add an avda instance.  This one must succeed immediately, since the last
  // one is still running.
  ASSERT_TRUE(StartThread(avda2_));

  // Stop the original avda instance.
  StopThread(avda1_);

  // Verify that the AUTO_CODEC thread is still running.
  ASSERT_TRUE(IsThreadRunning(TaskType::AUTO_CODEC));
  ASSERT_EQ(TaskType::AUTO_CODEC, TaskTypeForAllocation());

  // Remove the second instance and wait for it to stop.  Remember that it
  // stops after messages have been posted to the thread, so we don't know
  // how long it will take.
  StopThread(avda2_);

  // Verify that the threads have stopped.
  ASSERT_FALSE(IsThreadRunning(TaskType::AUTO_CODEC));
  ASSERT_FALSE(IsThreadRunning(TaskType::SW_CODEC));
}

TEST_F(AVDACodecAllocatorTest, TestHangThread) {
  ASSERT_EQ(TaskType::AUTO_CODEC, TaskTypeForAllocation());

  // Hang the AUTO_CODEC thread.
  base::WaitableEvent about_to_wait_event(
      base::WaitableEvent::ResetPolicy::MANUAL,
      base::WaitableEvent::InitialState::NOT_SIGNALED);
  base::WaitableEvent wait_event(
      base::WaitableEvent::ResetPolicy::MANUAL,
      base::WaitableEvent::InitialState::NOT_SIGNALED);
  TaskRunnerFor(TaskType::AUTO_CODEC)
      ->PostTask(FROM_HERE, base::Bind(&WaitUntilRestarted,
                                       &about_to_wait_event, &wait_event));
  // Wait until the task starts, so that |allocator_| starts the hang timer.
  about_to_wait_event.Wait();

  // Verify that we've failed over after a long time has passed.
  static_cast<MockTickClock*>(test_information_->tick_clock_.get())
      ->Advance(1000);
  // Note that this should return the SW codec task type even if that thread
  // failed to start.  TaskRunnerFor() will return the current thread in that
  // case too.
  ASSERT_EQ(TaskType::SW_CODEC, TaskTypeForAllocation());

  // Un-hang the thread and wait for it to let another task run.  This will
  // notify |allocator_| that the thread is no longer hung.
  base::WaitableEvent done_waiting_event(
      base::WaitableEvent::ResetPolicy::MANUAL,
      base::WaitableEvent::InitialState::NOT_SIGNALED);
  TaskRunnerFor(TaskType::AUTO_CODEC)
      ->PostTask(FROM_HERE,
                 base::Bind(&SignalImmediately, &done_waiting_event));
  wait_event.Signal();
  done_waiting_event.Wait();

  // Verify that we've un-failed over.
  ASSERT_EQ(TaskType::AUTO_CODEC, TaskTypeForAllocation());
}

TEST_F(AVDACodecAllocatorTest, AllocatingASurfaceTextureAlwaysSucceeds) {
  ASSERT_TRUE(
      allocator2_->AllocateSurface(avda1_, SurfaceManager::kNoSurfaceID));
  ASSERT_TRUE(
      allocator2_->AllocateSurface(avda2_, SurfaceManager::kNoSurfaceID));
}

TEST_F(AVDACodecAllocatorTest, AllocatingAnOwnedSurfaceFails) {
  ASSERT_TRUE(allocator2_->AllocateSurface(avda1_, 1));
  ASSERT_FALSE(allocator2_->AllocateSurface(avda2_, 1));
}

TEST_F(AVDACodecAllocatorTest, LaterWaitersReplaceEarlierWaiters) {
  allocator2_->AllocateSurface(avda1_, 1);
  allocator2_->AllocateSurface(avda2_, 1);
  EXPECT_CALL(*avda2_, OnSurfaceAvailable(false));
  allocator2_->AllocateSurface(avda3_, 1);
}

TEST_F(AVDACodecAllocatorTest, WaitersBecomeOwnersWhenSurfacesAreReleased) {
  allocator2_->AllocateSurface(avda1_, 1);
  allocator2_->AllocateSurface(avda2_, 1);
  EXPECT_CALL(*avda2_, OnSurfaceAvailable(true));
  allocator2_->DeallocateSurface(avda1_, 1);
  // The surface should still be owned.
  ASSERT_FALSE(allocator2_->AllocateSurface(avda1_, 1));
}

TEST_F(AVDACodecAllocatorTest, DeallocatingUnownedSurfacesIsSafe) {
  allocator2_->DeallocateSurface(avda1_, 1);
  allocator2_->DeallocateSurface(avda1_, SurfaceManager::kNoSurfaceID);
}

TEST_F(AVDACodecAllocatorTest, WaitersAreRemovedIfTheyDeallocate) {
  allocator2_->AllocateSurface(avda1_, 1);
  allocator2_->AllocateSurface(avda2_, 1);
  allocator2_->DeallocateSurface(avda2_, 1);
  // avda2_ should should not receive a notification.
  EXPECT_CALL(*avda2_, OnSurfaceAvailable(_)).Times(0);
  allocator2_->DeallocateSurface(avda1_, 1);
}

TEST_F(AVDACodecAllocatorTest, OwnersAreNotifiedOnDestruction) {
  allocator2_->AllocateSurface(avda1_, 1);
  // Not notified for a surface it doesn't own.
  EXPECT_CALL(*avda1_, OnSurfaceDestroyed()).Times(0);
  allocator2_->OnSurfaceDestroyed(123);
  // But notified for a surface it does own.
  EXPECT_CALL(*avda1_, OnSurfaceDestroyed());
  allocator2_->OnSurfaceDestroyed(1);
}

TEST_F(AVDACodecAllocatorTest, WaitersAreNotifiedOnDestruction) {
  allocator2_->AllocateSurface(avda1_, 1);
  allocator2_->AllocateSurface(avda2_, 1);
  EXPECT_CALL(*avda2_, OnSurfaceAvailable(false));
  allocator2_->OnSurfaceDestroyed(1);
}

TEST_F(AVDACodecAllocatorTest, DeallocatingIsSafeDuringSurfaceDestroyed) {
  allocator2_->AllocateSurface(avda1_, 1);
  EXPECT_CALL(*avda1_, OnSurfaceDestroyed()).WillOnce(Invoke([=]() {
    allocator2_->DeallocateSurface(avda1_, 1);
  }));
  allocator2_->OnSurfaceDestroyed(1);
}

}  // namespace media


text:
require 'test_helper'

describe Runlog do
   describe ".group_by_year" do
      before do
         @last_year_run = Runlog.create(start_time: Time.now - 1.year)
         @this_year_run = Runlog.create(start_time: Time.now)
         @next_year_run = Runlog.create(start_time: Time.now + 1.year)
      end

      subject { Runlog.group_by_year }

      it "年がキーとなっていること" do
         subject.keys.must_include Time.now.year
         subject.keys.must_include (Time.now - 1.year).year
         subject.keys.must_include (Time.now + 1.year).year
      end

      it "年ごとのデータが正しいこと" do
         subject[Time.now.year].must_include @this_year_run
         subject[(Time.now - 1.year).year].must_include @last_year_run
         subject[(Time.now + 1.year).year].must_include @next_year_run
      end
   end

   describe ".distance_vs_pace" do
      before do
         @last_year_run = Runlog.create(start_time: Time.now - 1.year, distance: 1, duration: 1000)
         @this_year_run1 = Runlog.create(start_time: Time.now, distance: 2, duration: 1000)
         @this_year_run2 = Runlog.create(start_time: Time.now, distance: 10, duration: 2_000)
      end
      subject { Runlog.distance_vs_pace }

      it "前年のデータが正しいこと" do
         subject[(Time.now - 1.year).year].must_equal([[1.0, 1.0]])
      end

      it "今年のデータが正しいこと" do
         subject[Time.now.year].must_equal([[2.0, 0.5], [10.0, 0.2]])
      end
   end

   describe "#pace" do
      subject { Runlog.new(distance: 2, duration: 1000) }
      # pace = ( duration / 1000 ) / distance
      it { subject.pace.must_equal 0.5 }
   end
end


text:
<title>Class Members</title>
<link href="doxygen.css" rel="stylesheet" type="text/css">
<link href="tabs.css" rel="stylesheet" type="text/css">
<link href="search/search.css" rel="stylesheet" type="text/css"/>

Main Page

Namespaces

Classes

Files

          <input type="text" id="MSearchField" value="Search" accesskey="S"
               onfocus="searchBox.OnSearchFieldFocus(true)"
               onblur="searchBox.OnSearchFieldFocus(false)"
               onkeyup="searchBox.OnSearchFieldChange(event)"/>

Class List

Class Hierarchy

Class Members

All

Functions

Variables

Typedefs

_

a

b

c

d

e

f

g

i

l

m

n

o

p

r

s

t

u

v

w

x

y

~

 All Classes Namespaces Files Functions Variables Typedefs

Here is a list of all class members with links to the classes they belong to:

- i -

IncBitAct()
: MOFSRule

increm
: MOFSRule

init()
: MOFSRule

initRulestore()
: mofs::MOFSModel

input
: MOFSVar

input0()
: MOFSRule

input1()
: MOFSRule

input2()
: MOFSRule

inputIrq()
: mofs::MOFSModel

inputs
: mofs::FuzzyControl_IORequest_< ContainerAllocator >
, MOFSRule

inputs_array()
: MOFSRule

inputs_sets
: mofs::RuleData

inputs_values
: mofs::RuleData

inputsVars
: mofs::MOFSModel

insertRuleVar()
: mofs::MOFSModel

insertVar()
: mofs::MOFSModel

ipts
: MOFSRule

mofs

Author(s): Miguel A. Olivares-Mendez

autogenerated on Wed Oct 16 2013 16:14:48


text:
This data indicates maximum value of Goal Acceleration(606).
[Goal Acceleration(606)] can't be configured with any values exceeding the [Acceleration Limit(26)].

Attempting to write an exceeding value will result transmitting Data Limit Error(0x06) in the Error field of the Status Packet.
[Goal Acceleration(606)] is used in all operating mode except Current(Torque) Control Mode in order to generate a desired trajectory.

|    Value Range    |
|:-----------------:|
| 0 ~ 2,147,483,647 |

[Acceleration Limit(26)]: #acceleration-limit26
[Goal Acceleration(606)]: #goal-acceleration606


text:
<!DOCTYPE html>

    <meta content="en-us" http-equiv="Content-Language" />
    <meta content="text/html; charset=utf-16" http-equiv="Content-Type" />
    <title _locid="PortabilityAnalysis0">.NET Portability Report</title>

.NET Portability Report

                    Submission Id
                    1559d587-27a9-447b-a81c-834f22d95789

            Portability Summary

                        Assembly
                            ASP.NET 5,Version=v1.0
                            Windows,Version=v8.1
                            .NET Framework,Version=v4.6
                            Windows Phone,Version=v8.1

                            Rxx
                                95.03 %
                                92.43 %
                                100.00 %
                                91.95 %

Rxx

                                Target type
                                ASP.NET 5,Version=v1.0
                                Windows,Version=v8.1
                                .NET Framework,Version=v4.6
                                Windows Phone,Version=v8.1
                                Recommended changes

                                    System.Activator

                                        CreateInstance(System.Type,System.Boolean)

                                    System.Char

                                Use System.Globalization.CharUnicodeInfo.GetUnicodeCategory(Char)

                                        GetUnicodeCategory(System.Char)

                                    Use System.Globalization.CharUnicodeInfo.GetUnicodeCategory(Char)

                                    System.Collections.Generic.KeyedByTypeCollection`1

                                    System.Collections.Generic.List`1

                                        AsReadOnly

                                    Call System.Collections.ObjectModel.ReadOnlyCollection<T> constructor

                                        ForEach(System.Action{`0})

                                    System.Collections.ObjectModel.ObservableCollection`1

                                        #ctor(System.Collections.Generic.List{`0})

                                    System.Collections.Specialized.NameValueCollection

                                    System.ComponentModel.Component

                                Remove usage

                                        Dispose

                                    Remove usage

                                    System.ComponentModel.DependencyPropertyDescriptor

                                        FromProperty(System.Windows.DependencyProperty,System.Type)

                                    System.ComponentModel.DesignerProperties

                                        GetIsInDesignMode(System.Windows.DependencyObject)

                                    System.ComponentModel.DesignerSerializationVisibility

                                    System.ComponentModel.DesignerSerializationVisibilityAttribute

                                        #ctor(System.ComponentModel.DesignerSerializationVisibility)

                                    System.ComponentModel.EventDescriptor

                                        AddEventHandler(System.Object,System.Delegate)

                                        get_EventType

                                        RemoveEventHandler(System.Object,System.Delegate)

                                    System.ComponentModel.EventDescriptorCollection

                                    System.ComponentModel.InvalidEnumArgumentException

                                Use a different Exception type such as System.ArgumentOutOfRangeException

                                        #ctor(System.String,System.Int32,System.Type)

                                    System.ComponentModel.ITypeDescriptorContext

                                Currently there is no workaround, but we are working on it. Please check back.

                                    System.ComponentModel.MemberDescriptor

                                        get_Name

                                    System.ComponentModel.PropertyDescriptor

                                        AddValueChanged(System.Object,System.EventHandler)

                                        get_IsReadOnly

                                        get_PropertyType

                                        get_SupportsChangeEvents

                                        GetValue(System.Object)

                                        RemoveValueChanged(System.Object,System.EventHandler)

                                        SetValue(System.Object,System.Object)

                                    System.ComponentModel.PropertyDescriptorCollection

                                    System.ComponentModel.TypeConverter

                                        CanConvertFrom(System.Type)

                                        CanConvertTo(System.Type)

                                        ConvertFrom(System.ComponentModel.ITypeDescriptorContext,System.Globalization.CultureInfo,System.Object)

                                        ConvertTo(System.ComponentModel.ITypeDescriptorContext,System.Globalization.CultureInfo,System.Object,System.Type)

                                    System.ComponentModel.TypeConverterAttribute

                                        #ctor(System.Type)

                                    System.ComponentModel.TypeDescriptor

                                        GetConverter(System.Object)

                                        GetConverter(System.Type)

                                    Currently there is no workaround, but we are working on it. Please check back.

                                        GetEvents(System.Object)

                                        GetProperties(System.Object)

                                    System.Configuration.ApplicationSettingsBase

                                        add_PropertyChanged(System.ComponentModel.PropertyChangedEventHandler)

                                        remove_PropertyChanged(System.ComponentModel.PropertyChangedEventHandler)

                                    System.Configuration.SettingsBase

                                        get_PropertyValues

                                    System.Configuration.SettingsPropertyValue

                                    System.Configuration.SettingsPropertyValueCollection

                                        get_Item(System.String)

                                    System.Data.CommandBehavior

                                    System.Data.SqlClient.OnChangeEventHandler

                                    System.Data.SqlClient.SqlCommand

                                        add_StatementCompleted(System.Data.StatementCompletedEventHandler)

                                        BeginExecuteNonQuery(System.AsyncCallback,System.Object)

                                        BeginExecuteReader(System.AsyncCallback,System.Object)

                                        BeginExecuteReader(System.AsyncCallback,System.Object,System.Data.CommandBehavior)

                                        BeginExecuteXmlReader(System.AsyncCallback,System.Object)

                                        EndExecuteNonQuery(System.IAsyncResult)

                                        EndExecuteReader(System.IAsyncResult)

                                        EndExecuteXmlReader(System.IAsyncResult)

                                        remove_StatementCompleted(System.Data.StatementCompletedEventHandler)

                                    System.Data.SqlClient.SqlDataReader

                                    System.Data.SqlClient.SqlDependency

                                        #ctor(System.Data.SqlClient.SqlCommand)

                                        #ctor(System.Data.SqlClient.SqlCommand,System.String,System.Int32)

                                        add_OnChange(System.Data.SqlClient.OnChangeEventHandler)

                                        remove_OnChange(System.Data.SqlClient.OnChangeEventHandler)

                                    System.Data.SqlClient.SqlNotificationEventArgs

                                    System.Data.StatementCompletedEventArgs

                                    System.Data.StatementCompletedEventHandler

                                    System.Delegate

                                Use MethodInfo.CreateDelegate

                                        CreateDelegate(System.Type,System.Object,System.Reflection.MethodInfo)

                                    Use MethodInfo.CreateDelegate

                                    System.Diagnostics.Contracts.Internal.ContractHelper

                                        RaiseContractFailedEvent(System.Diagnostics.Contracts.ContractFailureKind,System.String,System.String,System.Exception)

                                    System.Diagnostics.PresentationTraceSources

                                        get_DataBindingSource

                                    System.Diagnostics.SourceLevels

                                    System.Diagnostics.SourceSwitch

                                        get_Level

                                        set_Level(System.Diagnostics.SourceLevels)

                                        ShouldTrace(System.Diagnostics.TraceEventType)

                                    System.Diagnostics.Trace

                                        TraceError(System.String)

                                        TraceError(System.String,System.Object[])

                                        TraceInformation(System.String)

                                        TraceWarning(System.String,System.Object[])

                                    System.Diagnostics.TraceEventType

                                    System.Diagnostics.TraceListener

                                        Write(System.Object)

                                    System.Diagnostics.TraceListenerCollection

                                        Add(System.Diagnostics.TraceListener)

                                        Clear

                                        GetEnumerator

                                        Remove(System.Diagnostics.TraceListener)

                                    System.Diagnostics.TraceSource

                                        #ctor(System.String,System.Diagnostics.SourceLevels)

                                        get_Listeners

                                        get_Switch

                                        TraceEvent(System.Diagnostics.TraceEventType,System.Int32,System.String)

                                        TraceEvent(System.Diagnostics.TraceEventType,System.Int32,System.String,System.Object[])

                                        TraceInformation(System.String)

                                        TraceInformation(System.String,System.Object[])

                                    System.Exception

                                Remove.  Ctor overload taking SerializationInfo is not applicable in new surface area

                                        #ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)

                                    Remove.  Ctor overload taking SerializationInfo is not applicable in new surface area

                                        add_SerializeObjectState(System.EventHandler{System.Runtime.Serialization.SafeSerializationEventArgs})

                                    Remove usage.

                                        GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)

                                    Remove.  Getting rid of other usage of SerializationInfo will remove the need for this method.

                                    System.IO.Directory

                                        EnumerateFiles(System.String,System.String,System.IO.SearchOption)

                                    System.IO.DirectoryInfo

                                    System.IO.ErrorEventArgs

                                        GetException

                                    System.IO.ErrorEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.IO.File

                                        Open(System.String,System.IO.FileMode,System.IO.FileAccess,System.IO.FileShare)

                                    System.IO.FileAccess

                                    System.IO.FileMode

                                    System.IO.FileShare

                                    System.IO.FileStream

                                        get_Name

                                    System.IO.FileSystemEventArgs

                                        get_ChangeType

                                        get_FullPath

                                        get_Name

                                    System.IO.FileSystemEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.IO.FileSystemInfo

                                        get_FullName

                                    System.IO.FileSystemWatcher

                                        #ctor(System.String,System.String)

                                        add_Changed(System.IO.FileSystemEventHandler)

                                        add_Created(System.IO.FileSystemEventHandler)

                                        add_Deleted(System.IO.FileSystemEventHandler)

                                        add_Error(System.IO.ErrorEventHandler)

                                        add_Renamed(System.IO.RenamedEventHandler)

                                        get_Filter

                                        get_IncludeSubdirectories

                                        get_InternalBufferSize

                                        get_Path

                                        remove_Changed(System.IO.FileSystemEventHandler)

                                        remove_Created(System.IO.FileSystemEventHandler)

                                        remove_Deleted(System.IO.FileSystemEventHandler)

                                        remove_Error(System.IO.ErrorEventHandler)

                                        remove_Renamed(System.IO.RenamedEventHandler)

                                        set_EnableRaisingEvents(System.Boolean)

                                        set_IncludeSubdirectories(System.Boolean)

                                        set_InternalBufferSize(System.Int32)

                                        set_NotifyFilter(System.IO.NotifyFilters)

                                    System.IO.NotifyFilters

                                    System.IO.RenamedEventArgs

                                        get_OldFullPath

                                        get_OldName

                                    System.IO.RenamedEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.IO.SearchOption

                                    System.IO.Stream

                                Use Stream.ReadAsync

                                        BeginRead(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)

                                    Use Stream.ReadAsync

                                        BeginWrite(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)

                                    Use Stream.WriteAsync

                                        EndRead(System.IAsyncResult)

                                    Use Stream.ReadAsync

                                        EndWrite(System.IAsyncResult)

                                    Use Stream.WriteAsync

                                    System.IO.WatcherChangeTypes

                                    System.Net.Dns

                                        BeginGetHostAddresses(System.String,System.AsyncCallback,System.Object)

                                        BeginGetHostEntry(System.Net.IPAddress,System.AsyncCallback,System.Object)

                                        BeginGetHostEntry(System.String,System.AsyncCallback,System.Object)

                                        EndGetHostAddresses(System.IAsyncResult)

                                        EndGetHostEntry(System.IAsyncResult)

                                    System.Net.DownloadDataCompletedEventArgs

                                        get_Result

                                    System.Net.DownloadDataCompletedEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.Net.DownloadProgressChangedEventArgs

                                    System.Net.DownloadProgressChangedEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.Net.DownloadStringCompletedEventArgs

                                        get_Result

                                    System.Net.DownloadStringCompletedEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.Net.EndPoint

                                    System.Net.FtpWebRequest

                                    System.Net.FtpWebResponse

                                    System.Net.HttpListener

                                        #ctor

                                        BeginGetContext(System.AsyncCallback,System.Object)

                                        EndGetContext(System.IAsyncResult)

                                        get_IsListening

                                        get_Prefixes

                                        Start

                                        Stop

                                    System.Net.HttpListenerContext

                                    System.Net.HttpListenerPrefixCollection

                                        Add(System.String)

                                    System.Net.HttpWebRequest

                                        EndGetRequestStream(System.IAsyncResult,System.Net.TransportContext@)

                                    System.Net.IPAddress

                                    System.Net.IPEndPoint

                                        get_Address

                                        get_Port

                                    System.Net.IPHostEntry

                                    System.Net.Mail.MailMessage

                                    System.Net.Mail.SendCompletedEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.Net.Mail.SmtpClient

                                        #ctor

                                        add_SendCompleted(System.Net.Mail.SendCompletedEventHandler)

                                        remove_SendCompleted(System.Net.Mail.SendCompletedEventHandler)

                                        SendAsync(System.Net.Mail.MailMessage,System.Object)

                                        SendAsync(System.String,System.String,System.String,System.String,System.Object)

                                        SendAsyncCancel

                                    System.Net.NetworkInformation.NetworkAvailabilityChangedEventHandler

                                    System.Net.NetworkInformation.NetworkChange

                                        add_NetworkAvailabilityChanged(System.Net.NetworkInformation.NetworkAvailabilityChangedEventHandler)

                                        remove_NetworkAvailabilityChanged(System.Net.NetworkInformation.NetworkAvailabilityChangedEventHandler)

                                    System.Net.NetworkInformation.NetworkInterface

                                        GetAllNetworkInterfaces

                                    System.Net.NetworkInformation.Ping

                                        #ctor

                                        add_PingCompleted(System.Net.NetworkInformation.PingCompletedEventHandler)

                                        remove_PingCompleted(System.Net.NetworkInformation.PingCompletedEventHandler)

                                        SendAsync(System.Net.IPAddress,System.Int32,System.Byte[],System.Net.NetworkInformation.PingOptions,System.Object)

                                        SendAsync(System.Net.IPAddress,System.Int32,System.Byte[],System.Object)

                                        SendAsync(System.Net.IPAddress,System.Int32,System.Object)

                                        SendAsync(System.Net.IPAddress,System.Object)

                                        SendAsync(System.String,System.Int32,System.Byte[],System.Net.NetworkInformation.PingOptions,System.Object)

                                        SendAsync(System.String,System.Int32,System.Byte[],System.Object)

                                        SendAsync(System.String,System.Int32,System.Object)

                                        SendAsync(System.String,System.Object)

                                        SendAsyncCancel

                                    System.Net.NetworkInformation.PingCompletedEventArgs

                                        get_Reply

                                    System.Net.NetworkInformation.PingCompletedEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.Net.NetworkInformation.PingOptions

                                    System.Net.NetworkInformation.PingReply

                                    System.Net.OpenReadCompletedEventArgs

                                        get_Result

                                    System.Net.OpenReadCompletedEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.Net.OpenWriteCompletedEventArgs

                                        get_Result

                                    System.Net.OpenWriteCompletedEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.Net.Sockets.AddressFamily

                                    System.Net.Sockets.IPPacketInformation

                                    System.Net.Sockets.ProtocolType

                                    System.Net.Sockets.Socket

                                        #ctor(System.Net.Sockets.AddressFamily,System.Net.Sockets.SocketType,System.Net.Sockets.ProtocolType)

                                        AcceptAsync(System.Net.Sockets.SocketAsyncEventArgs)

                                        BeginAccept(System.AsyncCallback,System.Object)

                                        BeginAccept(System.Int32,System.AsyncCallback,System.Object)

                                        BeginAccept(System.Net.Sockets.Socket,System.Int32,System.AsyncCallback,System.Object)

                                        BeginConnect(System.Net.EndPoint,System.AsyncCallback,System.Object)

                                        BeginConnect(System.Net.IPAddress,System.Int32,System.AsyncCallback,System.Object)

                                        BeginConnect(System.Net.IPAddress[],System.Int32,System.AsyncCallback,System.Object)

                                        BeginConnect(System.String,System.Int32,System.AsyncCallback,System.Object)

                                        BeginDisconnect(System.Boolean,System.AsyncCallback,System.Object)

                                        BeginReceive(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)

                                        BeginReceive(System.Collections.Generic.IList{System.ArraySegment{System.Byte}},System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)

                                        BeginReceiveFrom(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint@,System.AsyncCallback,System.Object)

                                        BeginReceiveMessageFrom(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint@,System.AsyncCallback,System.Object)

                                        BeginSend(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)

                                        BeginSend(System.Collections.Generic.IList{System.ArraySegment{System.Byte}},System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)

                                        BeginSendFile(System.String,System.AsyncCallback,System.Object)

                                        BeginSendFile(System.String,System.Byte[],System.Byte[],System.Net.Sockets.TransmitFileOptions,System.AsyncCallback,System.Object)

                                        BeginSendTo(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint,System.AsyncCallback,System.Object)

                                        Bind(System.Net.EndPoint)

                                        ConnectAsync(System.Net.Sockets.SocketAsyncEventArgs)

                                        ConnectAsync(System.Net.Sockets.SocketType,System.Net.Sockets.ProtocolType,System.Net.Sockets.SocketAsyncEventArgs)

                                        DisconnectAsync(System.Net.Sockets.SocketAsyncEventArgs)

                                        EndAccept(System.Byte[]@,System.Int32@,System.IAsyncResult)

                                        EndAccept(System.IAsyncResult)

                                        EndConnect(System.IAsyncResult)

                                        EndDisconnect(System.IAsyncResult)

                                        EndReceive(System.IAsyncResult)

                                        EndReceiveFrom(System.IAsyncResult,System.Net.EndPoint@)

                                        EndReceiveMessageFrom(System.IAsyncResult,System.Net.Sockets.SocketFlags@,System.Net.EndPoint@,System.Net.Sockets.IPPacketInformation@)

                                        EndSend(System.IAsyncResult)

                                        EndSendFile(System.IAsyncResult)

                                        EndSendTo(System.IAsyncResult)

                                        get_IsBound

                                        get_ReceiveBufferSize

                                        Listen(System.Int32)

                                        ReceiveAsync(System.Net.Sockets.SocketAsyncEventArgs)

                                        ReceiveFromAsync(System.Net.Sockets.SocketAsyncEventArgs)

                                        ReceiveMessageFromAsync(System.Net.Sockets.SocketAsyncEventArgs)

                                        SendAsync(System.Net.Sockets.SocketAsyncEventArgs)

                                        SendPacketsAsync(System.Net.Sockets.SocketAsyncEventArgs)

                                        SendToAsync(System.Net.Sockets.SocketAsyncEventArgs)

                                    System.Net.Sockets.SocketAsyncEventArgs

                                        #ctor

                                        add_Completed(System.EventHandler{System.Net.Sockets.SocketAsyncEventArgs})

                                        get_AcceptSocket

                                        get_BytesTransferred

                                        get_ConnectByNameError

                                        get_LastOperation

                                        get_SocketError

                                        remove_Completed(System.EventHandler{System.Net.Sockets.SocketAsyncEventArgs})

                                        set_RemoteEndPoint(System.Net.EndPoint)

                                        set_SocketFlags(System.Net.Sockets.SocketFlags)

                                        SetBuffer(System.Byte[],System.Int32,System.Int32)

                                    System.Net.Sockets.SocketAsyncOperation

                                    System.Net.Sockets.SocketError

                                    System.Net.Sockets.SocketException

                                        #ctor(System.Int32)

                                    System.Net.Sockets.SocketFlags

                                    System.Net.Sockets.SocketType

                                    System.Net.Sockets.TcpClient

                                        BeginConnect(System.Net.IPAddress,System.Int32,System.AsyncCallback,System.Object)

                                        BeginConnect(System.Net.IPAddress[],System.Int32,System.AsyncCallback,System.Object)

                                        BeginConnect(System.String,System.Int32,System.AsyncCallback,System.Object)

                                        EndConnect(System.IAsyncResult)

                                    System.Net.Sockets.TcpListener

                                        #ctor(System.Net.IPAddress,System.Int32)

                                        #ctor(System.Net.IPEndPoint)

                                        BeginAcceptSocket(System.AsyncCallback,System.Object)

                                        BeginAcceptTcpClient(System.AsyncCallback,System.Object)

                                        EndAcceptSocket(System.IAsyncResult)

                                        EndAcceptTcpClient(System.IAsyncResult)

                                        get_Server

                                        Start

                                        Stop

                                    System.Net.Sockets.TransmitFileOptions

                                    System.Net.UploadDataCompletedEventArgs

                                        get_Result

                                    System.Net.UploadDataCompletedEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.Net.UploadFileCompletedEventArgs

                                        get_Result

                                    System.Net.UploadFileCompletedEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.Net.UploadProgressChangedEventArgs

                                Not available in .NET Core - use HttpClient API instead

                                    System.Net.UploadProgressChangedEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.Net.UploadStringCompletedEventArgs

                                        get_Result

                                    System.Net.UploadStringCompletedEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.Net.UploadValuesCompletedEventArgs

                                        get_Result

                                    System.Net.UploadValuesCompletedEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.Net.WebClient

                                        #ctor

                                    Use HttpClient instead

                                        add_DownloadDataCompleted(System.Net.DownloadDataCompletedEventHandler)

                                        add_DownloadFileCompleted(System.ComponentModel.AsyncCompletedEventHandler)

                                        add_DownloadProgressChanged(System.Net.DownloadProgressChangedEventHandler)

                                        add_DownloadStringCompleted(System.Net.DownloadStringCompletedEventHandler)

                                        add_OpenReadCompleted(System.Net.OpenReadCompletedEventHandler)

                                        add_OpenWriteCompleted(System.Net.OpenWriteCompletedEventHandler)

                                        add_UploadDataCompleted(System.Net.UploadDataCompletedEventHandler)

                                        add_UploadFileCompleted(System.Net.UploadFileCompletedEventHandler)

                                        add_UploadProgressChanged(System.Net.UploadProgressChangedEventHandler)

                                        add_UploadStringCompleted(System.Net.UploadStringCompletedEventHandler)

                                        add_UploadValuesCompleted(System.Net.UploadValuesCompletedEventHandler)

                                        CancelAsync

                                    Use HttpClient instead

                                        DownloadDataAsync(System.Uri,System.Object)

                                    Use HttpClient instead

                                        DownloadFileAsync(System.Uri,System.String,System.Object)

                                    Use HttpClient instead

                                        DownloadStringAsync(System.Uri,System.Object)

                                        OpenReadAsync(System.Uri,System.Object)

                                        OpenWriteAsync(System.Uri,System.String,System.Object)

                                        remove_DownloadDataCompleted(System.Net.DownloadDataCompletedEventHandler)

                                        remove_DownloadFileCompleted(System.ComponentModel.AsyncCompletedEventHandler)

                                        remove_DownloadProgressChanged(System.Net.DownloadProgressChangedEventHandler)

                                        remove_DownloadStringCompleted(System.Net.DownloadStringCompletedEventHandler)

                                        remove_OpenReadCompleted(System.Net.OpenReadCompletedEventHandler)

                                        remove_OpenWriteCompleted(System.Net.OpenWriteCompletedEventHandler)

                                        remove_UploadDataCompleted(System.Net.UploadDataCompletedEventHandler)

                                        remove_UploadFileCompleted(System.Net.UploadFileCompletedEventHandler)

                                        remove_UploadProgressChanged(System.Net.UploadProgressChangedEventHandler)

                                        remove_UploadStringCompleted(System.Net.UploadStringCompletedEventHandler)

                                        remove_UploadValuesCompleted(System.Net.UploadValuesCompletedEventHandler)

                                        UploadDataAsync(System.Uri,System.String,System.Byte[],System.Object)

                                        UploadFileAsync(System.Uri,System.String,System.String,System.Object)

                                        UploadStringAsync(System.Uri,System.String,System.String,System.Object)

                                        UploadValuesAsync(System.Uri,System.String,System.Collections.Specialized.NameValueCollection,System.Object)

                                    System.Reflection.Binder

                                Use an overload that does not take a Binder.

                                    System.Reflection.BindingFlags

                                    System.Reflection.MemberTypes

                                Use is operator.  Example:  if (membertype == membertypes.Field) --> if (member is FieldInfo)

                                    System.Reflection.MethodBase

                                        Invoke(System.Object,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object[],System.Globalization.CultureInfo)

                                    System.Reflection.ParameterModifier

                                Use an overload that does not take a ParameterModifier array.

                                    System.Reflection.PropertyInfo

                                Use PropertyInfo.GetMethod property

                                        GetGetMethod

                                    Use PropertyInfo.GetMethod property

                                    System.Runtime.ConstrainedExecution.Cer

                                    System.Runtime.ConstrainedExecution.Consistency

                                    System.Runtime.ConstrainedExecution.ReliabilityContractAttribute

                                Remove usage

                                        #ctor(System.Runtime.ConstrainedExecution.Consistency,System.Runtime.ConstrainedExecution.Cer)

                                    Remove usage

                                    System.Runtime.Serialization.ISafeSerializationData

                                either 1) Delete Serialization info from exceptions (since this can't be remoted) or 2) Use a different serialization technology if not for exceptions.

                                        CompleteDeserialization(System.Object)

                                    either 1) Delete Serialization info from exceptions (since this can't be remoted) or 2) Use a different serialization technology if not for exceptions.

                                    System.Runtime.Serialization.SafeSerializationEventArgs

                                either 1) Delete Serialization info from exceptions (since this can't be remoted) or 2) Use a different serialization technology if not for exceptions.

                                        AddSerializedState(System.Runtime.Serialization.ISafeSerializationData)

                                    either 1) Delete Serialization info from exceptions (since this can't be remoted) or 2) Use a different serialization technology if not for exceptions.

                                    System.Runtime.Serialization.SerializationInfo

                                        AddValue(System.String,System.Int32)

                                        GetInt32(System.String)

                                    System.ServiceModel.Channels.BindingParameterCollection

                                    System.ServiceModel.CommunicationState

                                    System.ServiceModel.Description.ContractDescription

                                        get_Operations

                                    System.ServiceModel.Description.IContractBehavior

                                    System.ServiceModel.Description.IOperationBehavior

                                    System.ServiceModel.Description.MessageBodyDescription

                                        get_ReturnValue

                                    System.ServiceModel.Description.MessageDescription

                                        get_Body

                                        get_Direction

                                    System.ServiceModel.Description.MessageDescriptionCollection

                                    System.ServiceModel.Description.MessageDirection

                                    System.ServiceModel.Description.MessagePartDescription

                                        set_Type(System.Type)

                                    System.ServiceModel.Description.OperationDescription

                                        get_Behaviors

                                        get_Messages

                                        get_Name

                                        get_SyncMethod

                                    System.ServiceModel.Description.OperationDescriptionCollection

                                    System.ServiceModel.Description.ServiceEndpoint

                                    System.ServiceModel.Dispatcher.ClientOperation

                                    System.ServiceModel.Dispatcher.ClientRuntime

                                    System.ServiceModel.Dispatcher.DispatchOperation

                                        set_Invoker(System.ServiceModel.Dispatcher.IOperationInvoker)

                                    System.ServiceModel.Dispatcher.DispatchRuntime

                                    System.ServiceModel.Dispatcher.IOperationInvoker

                                    System.ServiceModel.ICommunicationObject

                                        add_Closed(System.EventHandler)

                                        add_Closing(System.EventHandler)

                                        add_Faulted(System.EventHandler)

                                        add_Opened(System.EventHandler)

                                        add_Opening(System.EventHandler)

                                        get_State

                                        remove_Closed(System.EventHandler)

                                        remove_Closing(System.EventHandler)

                                        remove_Faulted(System.EventHandler)

                                        remove_Opened(System.EventHandler)

                                        remove_Opening(System.EventHandler)

                                    System.ServiceModel.Syndication.Atom10FeedFormatter

                                        #ctor

                                    System.ServiceModel.Syndication.Rss20FeedFormatter

                                        #ctor

                                    System.ServiceModel.Syndication.SyndicationFeed

                                        get_Items

                                    System.ServiceModel.Syndication.SyndicationFeedFormatter

                                        get_Feed

                                        ReadFrom(System.Xml.XmlReader)

                                    System.ServiceModel.Syndication.SyndicationItem

                                        get_SourceFeed

                                        set_SourceFeed(System.ServiceModel.Syndication.SyndicationFeed)

                                    System.Threading.Thread

                                        get_CurrentThread

                                        get_ManagedThreadId

                                    System.Threading.ThreadPool

                                        GetMaxThreads(System.Int32@,System.Int32@)

                                    Change code to not depend on the size of the ThreadPool for functionality.  Portable code needs to be able to run correctly on multiple different ThreadPool implementations, not all of which support this method.

                                    System.Type

                                        get_Assembly

                                    .GetTypeInfo().Assembly

                                        get_ContainsGenericParameters

                                    .GetTypeInfo().ContainsGenericParameters

                                        get_DefaultBinder

                                        get_IsEnum

                                    .GetTypeInfo().IsEnum

                                        get_IsGenericType

                                    .GetTypeInfo().IsGenericType

                                        get_IsGenericTypeDefinition

                                    .GetTypeInfo().IsGenericTypeDefinition

                                        GetGenericArguments

                                        GetInterfaceMap(System.Type)

                                        GetInterfaces

                                        GetMember(System.String,System.Reflection.MemberTypes,System.Reflection.BindingFlags)

                                        GetMethod(System.String)

                                        GetMethod(System.String,System.Reflection.BindingFlags)

                                    Equivalent available: Add using for System.Reflection, and reference System.Reflection.TypeExtensions

                                        GetMethod(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Type[],System.Reflection.ParameterModifier[])

                                    Use GetMethod(string, Type[]) to search for public methods by name and parameter type or filter the results of GetMethods(BindingFlags) using LINQ for other queries.

                                        GetProperty(System.String)

                                        IsAssignableFrom(System.Type)

                                    System.Uri

                                use string literal of "http://" instead.

                                        SchemeDelimiter

                                        UriSchemeHttp

                                    use string literal of "http://" instead.

                                    System.Windows.Controls.ValidationRule

                                    System.Windows.CultureInfoIetfLanguageTagConverter

                                    System.Windows.Data.Binding

                                        DoNothing

                                        #ctor

                                        #ctor(System.String)

                                        get_AsyncState

                                        get_BindsDirectlyToSource

                                        get_ElementName

                                        get_IsAsync

                                        get_Path

                                        get_RelativeSource

                                        get_Source

                                        get_XPath

                                        set_AsyncState(System.Object)

                                        set_BindsDirectlyToSource(System.Boolean)

                                        set_ElementName(System.String)

                                        set_IsAsync(System.Boolean)

                                        set_Mode(System.Windows.Data.BindingMode)

                                        set_Path(System.Windows.PropertyPath)

                                        set_RelativeSource(System.Windows.Data.RelativeSource)

                                        set_Source(System.Object)

                                        set_XPath(System.String)

                                    System.Windows.Data.BindingBase

                                        get_BindingGroupName

                                        get_FallbackValue

                                        get_StringFormat

                                        get_TargetNullValue

                                        set_BindingGroupName(System.String)

                                        set_FallbackValue(System.Object)

                                        set_StringFormat(System.String)

                                        set_TargetNullValue(System.Object)

                                    System.Windows.Data.BindingExpressionBase

                                        UpdateTarget

                                    System.Windows.Data.BindingMode

                                    System.Windows.Data.BindingOperations

                                        SetBinding(System.Windows.DependencyObject,System.Windows.DependencyProperty,System.Windows.Data.BindingBase)

                                    System.Windows.Data.IMultiValueConverter

                                    System.Windows.Data.IValueConverter

                                        Convert(System.Object,System.Type,System.Object,System.Globalization.CultureInfo)

                                        ConvertBack(System.Object,System.Type,System.Object,System.Globalization.CultureInfo)

                                    System.Windows.Data.MultiBinding

                                        #ctor

                                        get_Bindings

                                        get_NotifyOnSourceUpdated

                                        get_NotifyOnTargetUpdated

                                        get_NotifyOnValidationError

                                        get_UpdateSourceExceptionFilter

                                        get_UpdateSourceTrigger

                                        get_ValidatesOnDataErrors

                                        get_ValidatesOnExceptions

                                        get_ValidationRules

                                        set_Converter(System.Windows.Data.IMultiValueConverter)

                                        set_NotifyOnSourceUpdated(System.Boolean)

                                        set_NotifyOnTargetUpdated(System.Boolean)

                                        set_NotifyOnValidationError(System.Boolean)

                                        set_UpdateSourceExceptionFilter(System.Windows.Data.UpdateSourceExceptionFilterCallback)

                                        set_UpdateSourceTrigger(System.Windows.Data.UpdateSourceTrigger)

                                        set_ValidatesOnDataErrors(System.Boolean)

                                        set_ValidatesOnExceptions(System.Boolean)

                                    System.Windows.Data.MultiBindingExpression

                                        get_BindingExpressions

                                    System.Windows.Data.RelativeSource

                                        #ctor(System.Windows.Data.RelativeSourceMode,System.Type,System.Int32)

                                    System.Windows.Data.RelativeSourceMode

                                    System.Windows.Data.UpdateSourceExceptionFilterCallback

                                    System.Windows.Data.UpdateSourceTrigger

                                    System.Windows.DependencyObject

                                        #ctor

                                        GetValue(System.Windows.DependencyProperty)

                                        SetValue(System.Windows.DependencyProperty,System.Object)

                                    System.Windows.DependencyProperty

                                        UnsetValue

                                        get_PropertyType

                                        Register(System.String,System.Type,System.Type,System.Windows.PropertyMetadata)

                                        RegisterAttached(System.String,System.Type,System.Type,System.Windows.PropertyMetadata)

                                    System.Windows.DependencyPropertyChangedEventArgs

                                        get_NewValue

                                    System.Windows.DependencyPropertyChangedEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.Windows.EventTrigger

                                        #ctor

                                        #ctor(System.Windows.RoutedEvent)

                                        get_RoutedEvent

                                    System.Windows.FrameworkElement

                                        add_DataContextChanged(System.Windows.DependencyPropertyChangedEventHandler)

                                        add_Loaded(System.Windows.RoutedEventHandler)

                                        add_Unloaded(System.Windows.RoutedEventHandler)

                                        get_DataContext

                                        get_IsLoaded

                                        remove_DataContextChanged(System.Windows.DependencyPropertyChangedEventHandler)

                                        remove_Loaded(System.Windows.RoutedEventHandler)

                                        remove_Unloaded(System.Windows.RoutedEventHandler)

                                        set_DataContext(System.Object)

                                    System.Windows.FrameworkPropertyMetadata

                                        #ctor(System.Object,System.Windows.FrameworkPropertyMetadataOptions,System.Windows.PropertyChangedCallback)

                                    System.Windows.FrameworkPropertyMetadataOptions

                                    System.Windows.Input.CanExecuteRoutedEventArgs

                                        set_CanExecute(System.Boolean)

                                    System.Windows.Input.CanExecuteRoutedEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.Windows.Input.CommandBinding

                                        #ctor(System.Windows.Input.ICommand,System.Windows.Input.ExecutedRoutedEventHandler,System.Windows.Input.CanExecuteRoutedEventHandler)

                                    System.Windows.Input.CommandBindingCollection

                                        Add(System.Windows.Input.CommandBinding)

                                        Remove(System.Windows.Input.CommandBinding)

                                    System.Windows.Input.CommandManager

                                        RegisterClassCommandBinding(System.Type,System.Windows.Input.CommandBinding)

                                    System.Windows.Input.ExecutedRoutedEventArgs

                                    System.Windows.Input.ExecutedRoutedEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                    System.Windows.Markup.ContentPropertyAttribute

                                        #ctor(System.String)

                                    System.Windows.Markup.IProvideValueTarget

                                        get_TargetObject

                                        get_TargetProperty

                                    System.Windows.Markup.MarkupExtension

                                        #ctor

                                        ProvideValue(System.IServiceProvider)

                                    System.Windows.PropertyChangedCallback

                                        #ctor(System.Object,System.IntPtr)

                                    System.Windows.PropertyMetadata

                                    System.Windows.PropertyPath

                                        #ctor(System.String,System.Object[])

                                    System.Windows.RoutedEvent

                                        get_HandlerType

                                    System.Windows.RoutedEventArgs

                                    System.Windows.RoutedEventHandler

                                        #ctor(System.Object,System.IntPtr)

                                        Invoke(System.Object,System.Windows.RoutedEventArgs)

                                    System.Windows.Threading.Dispatcher

                                        BeginInvoke(System.Delegate,System.Windows.Threading.DispatcherPriority,System.Object[])

                                        get_CurrentDispatcher

                                    System.Windows.Threading.DispatcherOperation

                                        Abort

                                        get_Status

                                    System.Windows.Threading.DispatcherOperationStatus

                                    System.Windows.Threading.DispatcherPriority

                                    System.Windows.UIElement

                                        AddHandler(System.Windows.RoutedEvent,System.Delegate,System.Boolean)

                                        get_CommandBindings

                                        RemoveHandler(System.Windows.RoutedEvent,System.Delegate)

                                    System.Windows.UIPropertyMetadata

                                        #ctor(System.Object,System.Windows.PropertyChangedCallback)

                    Back to Summary