text:
package com.gamingmesh.jobs.container;

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

import com.gamingmesh.jobs.Jobs;

import net.Zrips.CMILib.Logs.CMIDebug;

public class ExploreChunk {

    private List<Integer> playerIds = new ArrayList<>();
    private int dbId = -1;
    private boolean updated = false;

    public ExploreRespond addPlayer(int playerId) {
	if (isFullyExplored()) {
	    return new ExploreRespond(Jobs.getExploreManager().getPlayerAmount() + 1, false);
	}

	boolean newChunkForPlayer = false;
	if (!playerIds.contains(playerId)) {
	    if (playerIds.size() < Jobs.getExploreManager().getPlayerAmount()) {
		playerIds.add(playerId);
		updated = true;
	    }

	    newChunkForPlayer = true;
	}

	if (Jobs.getGCManager().ExploreCompact && playerIds.size() >= Jobs.getExploreManager().getPlayerAmount()) {
	    playerIds = null;
	}

	List<Integer> players = getPlayers();

	return new ExploreRespond(newChunkForPlayer ? players.size() : players.size() + 1, newChunkForPlayer);
    }

    public boolean isAlreadyVisited(int playerId) {
	return isFullyExplored() || playerIds.contains(playerId);
    }

    public int getCount() {
	return isFullyExplored() ? Jobs.getExploreManager().getPlayerAmount() : playerIds.size();
    }

    public List<Integer> getPlayers() {
	return playerIds == null ? new ArrayList<>() : playerIds;
    }

    public String serializeNames() {
	if (playerIds == null)
	    return null;

	StringBuilder s = new StringBuilder();
	for (Integer one : playerIds) {
	    if (s.length() != 0)
		s.append(';');

	    s.append(one);
	}
	return s.toString();
    }

    public void deserializeNames(String names) {
	if (names == null || names.isEmpty()) {
	    playerIds = null;
	    return;
	}

	if (playerIds == null) {
	    playerIds = new ArrayList<>();
	}

	for (String one : names.split(";")) {
	    try {
		int id = Integer.parseInt(one);

		if (Jobs.getPlayerManager().getPlayerInfo(id) != null)
		    playerIds.add(id);
	    } catch (NumberFormatException e) {
		updated = true;
	    }
	}

	if (Jobs.getGCManager().ExploreCompact && playerIds.size() >= Jobs.getExploreManager().getPlayerAmount()) {
	    playerIds = null;

	    if (!names.isEmpty())
		updated = true;
	}
    }

    public int getDbId() {
	return dbId;
    }

    public void setDbId(int dbId) {
	this.dbId = dbId;
    }

    public boolean isUpdated() {
	return updated;
    }

    public void setUpdated(boolean updated) {
	this.updated = updated;
    }

    public boolean isFullyExplored() {
	return playerIds == null || playerIds.size() >= Jobs.getExploreManager().getPlayerAmount();
    }
}


text:
@interface DemoViewController : UIViewController <ALPickerViewDelegate> {
	NSArray *entries;
	NSMutableDictionary *selectionStates;

	ALPickerView *pickerView;
}

@end

redpajama_set_name: RedPajamaGithub


text:
require('proof')(4, require('cadence')(prove))

function prove (async, okay) {
    var events = require('events')
    var ipc = require('..')

    ipc(false, null, null)

    async(function () {
        var process = new events.EventEmitter
        process.send = function (message) {
            okay(message, { from: 'child' }, 'process send')
            wait()
        }
        process.versions = { node: '0.10.43' }
        var child = new events.EventEmitter
        child.send = function (message) {
            okay(message, { from: 'parent' }, 'child send')
            child.emit('message', { from: 'child' })
        }
        var wait = async()

        ipc(true, process, child)

        process.emit('message', { from: 'parent' })
    }, function () {
        var process = new events.EventEmitter
        process.send = function (message, callback) {
            okay(message, { from: 'child' }, 'process send')
            callback()
            wait()
        }
        process.versions = { node: '4.2.3' }
        process.connected = true
        process.disconnect = function () { this.connected = false }
        var child = new events.EventEmitter
        child.send = function (message, callback) {
            okay(message, { from: 'parent' }, 'child send')
            child.emit('message', { from: 'child' })
            callback()
        }
        var wait = async()

        ipc(true, process, child)

        process.emit('message', { from: 'parent' })

        process.emit('SIGINT')
        process.emit('SIGINT')
    })
}


text:
package com.cbsb.wakelan;

import android.app.Activity;
import android.app.LocalActivityManager;

import android.net.Uri;
import android.os.Bundle;

import android.content.Context;
import android.content.Intent;
import android.content.UriMatcher;
import android.content.ContentValues;
import android.content.SharedPreferences;
import android.graphics.Color;
import android.graphics.Typeface;

import android.util.Log;

import android.widget.TabHost;
import android.widget.TabHost.OnTabChangeListener;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.EditText;
import android.widget.Button;
import android.widget.Toast;
import android.widget.TextView;
import android.widget.AdapterView;
import android.widget.AdapterView.AdapterContextMenuInfo;

import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnFocusChangeListener;
import android.view.ContextMenu;
import android.view.Menu;
import android.view.MenuItem;
import android.view.ContextMenu.ContextMenuInfo;
import android.view.MenuInflater;
import com.cbsb.wakelan.R;

/**
 *	@desc	Base activity, handles all UI events except history ListView clicks
 */
public class WakeOnLanActivity extends Activity implements OnClickListener, OnTabChangeListener, OnFocusChangeListener
{

	public static final String TAG = "WakeRemoteLan";

	public static final int MENU_ITEM_WAKE = Menu.FIRST;
	public static final int MENU_ITEM_DELETE = Menu.FIRST + 1;

	private static int _editModeID = 0;
	private static boolean typingMode = false;

	private static boolean isTablet = false;
	private TabHost th;

	private HistoryListHandler histHandler;
	private static int sort_mode;

	public static final int CREATED = 0;
	public static final int LAST_USED = 1;
	public static final int USED_COUNT = 2;
	public static final int About = 3;

	private static final String[] PROJECTION = new String[]
	{
		History.Items._ID,
		History.Items.TITLE,
		History.Items.MAC,
		History.Items.IP,
		History.Items.PORT,
		History.Items.LAST_USED_DATE,
		History.Items.USED_COUNT,
		History.Items.IS_STARRED
	};

	private static Toast notification;

	@Override
	public void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);

		//configure tabs
		th = (TabHost)findViewById(R.id.tabhost);

		// tabs only exist in phone layouts
		if(th != null) {
			WakeOnLanActivity.isTablet = true;

			LocalActivityManager lam = new LocalActivityManager(this, false);
			//lam.dispatchCreate(savedInstanceState);
			th.setup(lam);

			th.addTab(th.newTabSpec("tab_history").setIndicator(getString(R.string.tab_history), getResources().getDrawable(R.drawable.ical)).setContent(R.id.historyview));
		//	th.getTabWidget().getChildAt(0).setBackgroundResource(R.color.Grey);

			th.addTab(th.newTabSpec("tab_wake").setIndicator(getString(R.string.tab_wake), getResources().getDrawable(R.drawable.wake)).setContent(R.id.wakeview));
		//	th.getTabWidget().getChildAt(0).setBackgroundResource(R.color.Grey);

			th.setCurrentTab(0);

			//register self as tab changed listener
			th.setOnTabChangedListener(this);
		}else{
			//set the background color of the titles
			TextView historytitle = (TextView)findViewById(R.id.historytitle);
			historytitle.setBackgroundColor(Color.parseColor("#ffffff"));
			TextView waketitle = (TextView)findViewById(R.id.waketitle);
			waketitle.setBackgroundColor(Color.parseColor("#ffffff"));
		}

		//set defaults on Wake tab
		EditText vip = (EditText)findViewById(R.id.ip);
		vip.setText(MagicPacket.BROADCAST);
		EditText vport = (EditText)findViewById(R.id.port);
		vport.setText(Integer.toString(MagicPacket.PORT));

		//register self as listener for wake button
		Button sendWake = (Button)findViewById(R.id.send_wake);
		sendWake.setOnClickListener(this);
		Button clearWake = (Button)findViewById(R.id.clear_wake);
		clearWake.setOnClickListener(this);

		//register self as mac address field focus change listener
		EditText vmac = (EditText)findViewById(R.id.mac);
		vmac.setOnFocusChangeListener(this);

		Typeface tf1 = Typeface.createFromAsset(this.getAssets(), "fonts/Dungeon.TTF");
		TextView tv1 = (TextView) findViewById(R.id.reference1);
		TextView tm1 = (TextView) findViewById(R.id.mac1);
		TextView th1 = (TextView) findViewById(R.id.hostname1);
		TextView tp1 = (TextView) findViewById(R.id.port1);
		tv1.setTypeface(tf1);
		tm1.setTypeface(tf1);
		th1.setTypeface(tf1);
		tp1.setTypeface(tf1);

		//preferences
		SharedPreferences settings = getSharedPreferences(TAG, 0);
		SharedPreferences.Editor editor;

		// clean up old preferences
		if(settings.contains("check_for_update") == true) {
			editor = settings.edit();
			editor.remove("check_for_update");
			editor.remove("last_update");
			editor.commit();
		}

		//load our sort mode
		sort_mode = settings.getInt("sort_mode", CREATED);

		// grab the history ListView
		ListView lv = (ListView)findViewById(R.id.history);

		//load history handler (deals with cursor and history ListView)
		histHandler = new HistoryListHandler(this, lv);
		histHandler.bind(sort_mode);

		//register main Activity as context menu handler
		registerForContextMenu(lv);
	}

	public boolean onCreateOptionsMenu(Menu menu)
	{
		MenuInflater inflater = getMenuInflater();
		inflater.inflate(R.menu.main_menu, menu);

		MenuItem mi = null;

		switch (sort_mode) {
		case CREATED:
			mi = (MenuItem) menu.findItem(R.id.menu_created);
			break;
		case LAST_USED:
			mi = (MenuItem) menu.findItem(R.id.menu_lastused);
			break;
		case USED_COUNT:
			mi = (MenuItem) menu.findItem(R.id.menu_usedcount);
			break;
		case About:
			mi = (MenuItem) menu.findItem(R.id.about);
			break;

		}

		//toggle menuitem
		mi.setChecked(true);
		return true;
	}

	public boolean onOptionsItemSelected(MenuItem mi)
	{
		switch (mi.getItemId()) {
		case R.id.about:
        	Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://proalab.com/?page_id=517"));
			startActivity(browserIntent);
		case R.id.menu_created:
			sort_mode = CREATED;
			break;
		case R.id.menu_lastused:
			sort_mode = LAST_USED;
			break;
		case R.id.menu_usedcount:
			sort_mode = USED_COUNT;
			break;
		case R.id.menu_sortby:

			return false;
		}

		//toggle menuitem
		mi.setChecked(true);

		//save to preferences
		SharedPreferences.Editor editor = getSharedPreferences(TAG, 0).edit();
		editor.putInt("sort_mode", sort_mode);
		editor.commit();

		//rebind the history list
		histHandler.bind(sort_mode);
		return true;
	}

	public void onClick(View v)
	{
		if(v.getId() == R.id.send_wake) {
			EditText vtitle = (EditText)findViewById(R.id.title);
			EditText vmac = (EditText)findViewById(R.id.mac);
			EditText vip = (EditText)findViewById(R.id.ip);
			EditText vport = (EditText)findViewById(R.id.port);

			String title = vtitle.getText().toString().trim();
			String mac = vmac.getText().toString().trim();

			//default IP and port unless set on form
			String ip = MagicPacket.BROADCAST;
			if(!vip.getText().toString().trim().equals("")) {
				ip = vip.getText().toString().trim();
			}

			int port = MagicPacket.PORT;
			if(!vport.getText().toString().trim().equals("")) {
				try {
					port = Integer.valueOf(vport.getText().toString().trim());
				}catch(NumberFormatException nfe) {
					notifyUser("Bad port number", WakeOnLanActivity.this);
					return;
				}
			}

			//update form with cleaned variables
			vtitle.setText(title);
			vmac.setText(mac);
			vip.setText(ip);
			vport.setText(Integer.toString(port));

			//check for edit mode - no send of packet
			if(_editModeID == 0) {
				//send the magic packet
				String formattedMac = sendPacket(title, mac, ip, port);

				//on successful send, add to history list
				if(formattedMac != null) {
					histHandler.addToHistory(title, formattedMac, ip, port);
				}else{
					//return on sending failed
					return;
				}

			}else{
				String formattedMac = null;

				try {
					//validate and clean our mac address
					formattedMac = MagicPacket.cleanMac(mac);

				}catch(IllegalArgumentException iae) {
					notifyUser(iae.getMessage(), WakeOnLanActivity.this);
					return;
				}

				//update existing history entry
				histHandler.updateHistory(_editModeID, title, formattedMac, ip, port);

				//reset now edit mode complete
				_editModeID = 0;
			}

			//finished typing (either send or edit)
			typingMode = false;

			//switch back to the history tab
			if(WakeOnLanActivity.isTablet == true) {
				th.setCurrentTab(0);
			}

		}else if(v.getId() == R.id.clear_wake) {
			if(_editModeID == 0) {
				//clear the form
				EditText vtitle = (EditText)findViewById(R.id.title);
				vtitle.setText(null);
				EditText vmac = (EditText)findViewById(R.id.mac);
				vmac.setText(null);
				vmac.setError(null);
				EditText vip = (EditText)findViewById(R.id.ip);
				vip.setText(null);
				EditText vport = (EditText)findViewById(R.id.port);
				vport.setText(null);
			}else{
				//cancel editing
				_editModeID = 0;
				typingMode = false;

				//switch back to the history tab
				if(WakeOnLanActivity.isTablet == true) {
					th.setCurrentTab(0);
				}
			}
		}
	}

	public void onTabChanged(String tabId)
	{
		if(tabId.equals("tab_wake")) {
			//enter typing mode - no clear of form until exit typing mode
			typingMode = true;

		}else if(tabId.equals("tab_history")) {
			//set form back to defaults, if typing mode has ended (button was clicked)
			if(typingMode == false) {
				EditText vtitle = (EditText)findViewById(R.id.title);
				EditText vmac = (EditText)findViewById(R.id.mac);
				EditText vip = (EditText)findViewById(R.id.ip);
				EditText vport = (EditText)findViewById(R.id.port);

				vtitle.setText(null);
				vmac.setText(null);
				vip.setText(MagicPacket.BROADCAST);
				vport.setText(Integer.toString(MagicPacket.PORT));

				//clear any errors
				vmac.setError(null);

				//reset both our button's text
				Button sendWake = (Button)findViewById(R.id.send_wake);
				sendWake.setText(R.string.button_wake);
				Button clearWake = (Button)findViewById(R.id.clear_wake);
				clearWake.setText(R.string.button_clear);
			}
		}
	}

	public void onFocusChange(View v, boolean hasFocus)
	{
		//validate mac address on field exit
		if(hasFocus == false) {
			EditText vmac = (EditText)v;

			try {
				//validate our mac address
				String mac = vmac.getText().toString();
				if(mac.length() > 0) {
					mac = MagicPacket.cleanMac(mac);
					vmac.setText(mac);
				}
				vmac.setError(null);

			}catch(IllegalArgumentException iae) {
				vmac.setError(getString(R.string.invalid_mac));
			}
		}
	}

	public String sendPacket(HistoryItem item)
	{
		return sendPacket(item.title, item.mac, item.ip, item.port);
	}

	public String sendPacket(String title, String mac, String ip, int port)
	{
		String formattedMac = null;

		try {
			formattedMac = MagicPacket.send(mac, ip, port);

		}catch(IllegalArgumentException iae) {
			notifyUser(getString(R.string.send_failed)+":\n"+iae.getMessage(), WakeOnLanActivity.this);
			return null;

		}catch(Exception e) {
			notifyUser(getString(R.string.send_failed), WakeOnLanActivity.this);
			return null;
		}

		//display sent message to user
		notifyUser(getString(R.string.packet_sent)+" to "+title, WakeOnLanActivity.this);
		return formattedMac;
	}

	@Override
	public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo)
	{
		super.onCreateContextMenu(menu, v, menuInfo);
		MenuInflater inflater = getMenuInflater();
		inflater.inflate(R.menu.history_menu, menu);
	}

	@Override
	public boolean onContextItemSelected(MenuItem mi)
	{
		//extract data about clicked item
		AdapterContextMenuInfo info = (AdapterContextMenuInfo) mi.getMenuInfo();

		//extract history item
		HistoryItem item = histHandler.getItem(info.position);

		switch (mi.getItemId()) {
		case R.id.menu_wake:
			String mac = sendPacket(item);

			//update used count in DB
			if(sendPacket(item) != null) {
				histHandler.incrementHistory(item.id);
			}
			return true;

		case R.id.menu_edit:
			//save the id of record being edited
			_editModeID = item.id;

			//fire this record into edit mode in the next tab
			EditText vtitle = (EditText)findViewById(R.id.title);
			EditText vmac = (EditText)findViewById(R.id.mac);
			EditText vip = (EditText)findViewById(R.id.ip);
			EditText vport = (EditText)findViewById(R.id.port);

			//display editing data
			vtitle.setText(item.title);
			vmac.setText(item.mac);
			vip.setText(item.ip);
			vport.setText(Integer.toString(item.port));

			//clear any previous errors
			vmac.setError(null);

			//change text on both our buttons
			Button saveEdit = (Button)findViewById(R.id.send_wake);
			saveEdit.setText(R.string.button_save);
			Button cancelEdit = (Button)findViewById(R.id.clear_wake);
			cancelEdit.setText(R.string.button_cancel);

			if(WakeOnLanActivity.isTablet == true) {
				th.setCurrentTab(1);
			}
			return true;

		case R.id.menu_delete:
			histHandler.deleteHistory(item.id);
			return true;

		default:
			return super.onContextItemSelected(mi);
		}
	}

	public static void notifyUser(String message, Context context)
	{
		if (notification != null) {
			notification.setText(message);
			notification.show();
		} else {
			notification = Toast.makeText(context, message, Toast.LENGTH_SHORT);
			notification.show();
		}
	}

}


text:
(function () {
  'use strict';

  describe('Broadcasts Route Tests', function () {
    // Initialize global variables
    var $scope,
      BroadcastsService;

    //We can start by loading the main application module
    beforeEach(module(ApplicationConfiguration.applicationModuleName));

    // The injector ignores leading and trailing underscores here (i.e. _$httpBackend_).
    // This allows us to inject a service but then attach it to a variable
    // with the same name as the service.
    beforeEach(inject(function ($rootScope, _BroadcastsService_) {
      // Set a new global scope
      $scope = $rootScope.$new();
      BroadcastsService = _BroadcastsService_;
    }));

    describe('Route Config', function () {
      describe('Main Route', function () {
        var mainstate;
        beforeEach(inject(function ($state) {
          mainstate = $state.get('broadcasts');
        }));

        it('Should have the correct URL', function () {
          expect(mainstate.url).toEqual('/broadcasts');
        });

        it('Should be abstract', function () {
          expect(mainstate.abstract).toBe(true);
        });

        it('Should have template', function () {
          expect(mainstate.template).toBe('<ui-view/>');
        });
      });

      describe('View Route', function () {
        var viewstate,
          BroadcastsController,
          mockBroadcast;

        beforeEach(inject(function ($controller, $state, $templateCache) {
          viewstate = $state.get('broadcasts.view');
          $templateCache.put('modules/broadcasts/client/views/view-broadcast.client.view.html', '');

          // create mock Broadcast
          mockBroadcast = new BroadcastsService({
            _id: '525a8422f6d0f87f0e407a33',
            name: 'Broadcast Name'
          });

          //Initialize Controller
          BroadcastsController = $controller('BroadcastsController as vm', {
            $scope: $scope,
            broadcastResolve: mockBroadcast
          });
        }));

        it('Should have the correct URL', function () {
          expect(viewstate.url).toEqual('/:broadcastId');
        });

        it('Should have a resolve function', function () {
          expect(typeof viewstate.resolve).toEqual('object');
          expect(typeof viewstate.resolve.broadcastResolve).toEqual('function');
        });

        it('should respond to URL', inject(function ($state) {
          expect($state.href(viewstate, {
            broadcastId: 1
          })).toEqual('/broadcasts/1');
        }));

        it('should attach an Broadcast to the controller scope', function () {
          expect($scope.vm.broadcast._id).toBe(mockBroadcast._id);
        });

        it('Should not be abstract', function () {
          expect(viewstate.abstract).toBe(undefined);
        });

        it('Should have templateUrl', function () {
          expect(viewstate.templateUrl).toBe('modules/broadcasts/client/views/view-broadcast.client.view.html');
        });
      });

      describe('Create Route', function () {
        var createstate,
          BroadcastsController,
          mockBroadcast;

        beforeEach(inject(function ($controller, $state, $templateCache) {
          createstate = $state.get('broadcasts.create');
          $templateCache.put('modules/broadcasts/client/views/form-broadcast.client.view.html', '');

          // create mock Broadcast
          mockBroadcast = new BroadcastsService();

          //Initialize Controller
          BroadcastsController = $controller('BroadcastsController as vm', {
            $scope: $scope,
            broadcastResolve: mockBroadcast
          });
        }));

        it('Should have the correct URL', function () {
          expect(createstate.url).toEqual('/create');
        });

        it('Should have a resolve function', function () {
          expect(typeof createstate.resolve).toEqual('object');
          expect(typeof createstate.resolve.broadcastResolve).toEqual('function');
        });

        it('should respond to URL', inject(function ($state) {
          expect($state.href(createstate)).toEqual('/broadcasts/create');
        }));

        it('should attach an Broadcast to the controller scope', function () {
          expect($scope.vm.broadcast._id).toBe(mockBroadcast._id);
          expect($scope.vm.broadcast._id).toBe(undefined);
        });

        it('Should not be abstract', function () {
          expect(createstate.abstract).toBe(undefined);
        });

        it('Should have templateUrl', function () {
          expect(createstate.templateUrl).toBe('modules/broadcasts/client/views/form-broadcast.client.view.html');
        });
      });

      describe('Edit Route', function () {
        var editstate,
          BroadcastsController,
          mockBroadcast;

        beforeEach(inject(function ($controller, $state, $templateCache) {
          editstate = $state.get('broadcasts.edit');
          $templateCache.put('modules/broadcasts/client/views/form-broadcast.client.view.html', '');

          // create mock Broadcast
          mockBroadcast = new BroadcastsService({
            _id: '525a8422f6d0f87f0e407a33',
            name: 'Broadcast Name'
          });

          //Initialize Controller
          BroadcastsController = $controller('BroadcastsController as vm', {
            $scope: $scope,
            broadcastResolve: mockBroadcast
          });
        }));

        it('Should have the correct URL', function () {
          expect(editstate.url).toEqual('/:broadcastId/edit');
        });

        it('Should have a resolve function', function () {
          expect(typeof editstate.resolve).toEqual('object');
          expect(typeof editstate.resolve.broadcastResolve).toEqual('function');
        });

        it('should respond to URL', inject(function ($state) {
          expect($state.href(editstate, {
            broadcastId: 1
          })).toEqual('/broadcasts/1/edit');
        }));

        it('should attach an Broadcast to the controller scope', function () {
          expect($scope.vm.broadcast._id).toBe(mockBroadcast._id);
        });

        it('Should not be abstract', function () {
          expect(editstate.abstract).toBe(undefined);
        });

        it('Should have templateUrl', function () {
          expect(editstate.templateUrl).toBe('modules/broadcasts/client/views/form-broadcast.client.view.html');
        });

        xit('Should go to unauthorized route', function () {

        });
      });

    });
  });
})();


text:
IndexManager *indexManager;

int testCase_5b(const string &indexFileName, const Attribute &attribute)
{
    // Functions tested
    // 1. Create Index File
    // 2. Open Index File
    // 3. Insert entry
    // 4. Scan entries using LT_OP operator and checking if the values returned are correct.
    //    Returned values are part of two separate insertions. **
    // 5. Scan close
    // 6. Close Index File
    // 7. Destroy Index File
    // NOTE: "**" signifies the new functions being tested in this test case.
    cerr << endl << "****In Test Case 5b****" << endl;

    RID rid;
    IXFileHandle ixfileHandle;
    IX_ScanIterator ix_ScanIterator;
    unsigned numOfTuples = 2000;
    unsigned numOfMoreTuples = 6000;
    float key;
    float compVal = 6500;
    int inRidPageNumSum = 0;
    int outRidPageNumSum = 0;

    // create index file
    assertCreateIndexFile(success, indexManager, indexFileName);

    // open index file
    assertOpenIndexFile(success, indexManager, indexFileName, ixfileHandle);

    // insert entry
    for(unsigned i = 1; i <= numOfTuples; i++)
    {
        key = (float)i + 76.5;
        rid.pageNum = i;
        rid.slotNum = i;

        assertInsertEntry(success, indexManager, ixfileHandle, attribute, &key, rid);
        if (key < compVal)
        {
            inRidPageNumSum += rid.pageNum;
        }
    }

    for(unsigned i = 6000; i <= numOfTuples+numOfMoreTuples; i++)
    {
        key = (float)i + 76.5;
        rid.pageNum = i;
        rid.slotNum = i-(unsigned)500;

        assertInsertEntry(success, indexManager, ixfileHandle, attribute, &key, rid);

        if (key < compVal)
        {
            inRidPageNumSum += rid.pageNum;
        }
    }

    // scan
    assertInitalizeScan(success, indexManager, ixfileHandle, attribute,
            NULL, &compVal, true, false, ix_ScanIterator);

    // iterate
    while(ix_ScanIterator.getNextEntry(rid, &key) == success)
    {
        if(rid.pageNum % 500 == 0)
            cerr << "returned rid: " << rid.pageNum << " " << rid.slotNum << endl;
        outRidPageNumSum += rid.pageNum;
    }

    if (inRidPageNumSum != outRidPageNumSum)
    {
        cerr << "Wrong entries output...failure" << endl;
        ix_ScanIterator.close();
        return fail;
    }

    // close scan
    assertCloseIterator(success, ix_ScanIterator);

    // close index file(s)
    assertCloseIndexFile(success, indexManager, ixfileHandle);

    //destroy index file(s)
    assertDestroyIndexFile(success, indexManager, indexFileName);

    return success;

}

int main()
{
    //Global Initializations
    indexManager = IndexManager::instance();

    const string indexFileName = "height_idx";
    Attribute attrHeight;
    attrHeight.length = 4;
    attrHeight.name = "height";
    attrHeight.type = TypeReal;

    RC result = testCase_5b(indexFileName, attrHeight);
    if (result == success) {
        cerr << "IX_Test Case 5b passed" << endl;
        return success;
    } else {
        cerr << "IX_Test Case 5b failed" << endl;
        return fail;
    }

}


text:
@interface UIImage (Base64)

+(UIImage*)imageFromBase64String:(NSString*)string;
+(NSString*)base64StringFromUIImage:(UIImage*)image;

@end


text:
package in.twizmwaz.cardinal.module.modules.regions.parsers;

import in.twizmwaz.cardinal.module.modules.regions.RegionParser;
import in.twizmwaz.cardinal.util.NumUtils;
import org.jdom2.Element;

public class CircleParser extends RegionParser {

    private final double centerX, centerZ, radius;

    public CircleParser(Element element) {
        super(element.getAttributeValue("name"));
        String[] centArray = element.getAttributeValue("center").contains(",") ?
                element.getAttributeValue("center").trim().replaceAll(" ", "").split(",") :
                element.getAttributeValue("center").trim().replaceAll(" ", ",").split(",");
        this.centerX = NumUtils.parseDouble(centArray[0].trim());
        this.centerZ = NumUtils.parseDouble(centArray[1].trim());
        this.radius = NumUtils.parseDouble(element.getAttributeValue("radius"));
    }

    public double getCenterX() {
        return centerX;
    }

    public double getCenterZ() {
        return centerZ;
    }

    public double getRadius() {
        return radius;
    }
}


text:
namespace SimpleDomain.Bus.Configuration
{
    using System;
    using System.Collections.Generic;
    using System.Reflection;

    /// <summary>
    /// The Jitney configuration base class for IoC containers
    /// </summary>
    public abstract class AbstractIoCContainerJitneyConfiguration : AbstractJitneyConfiguration
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="AbstractIoCContainerJitneyConfiguration"/> class.
        /// </summary>
        /// <param name="handlerRegistry">Dependency injection for <see cref="AbstractHandlerRegistry"/></param>
        protected AbstractIoCContainerJitneyConfiguration(AbstractHandlerRegistry handlerRegistry)
            : base(handlerRegistry)
        {
        }

        /// <summary>
        /// Subscribes all message handlers in a given list of assemblies
        /// </summary>
        /// <param name="assemblies">The list of assemblies to scan and register for</param>
        public void SubscribeMessageHandlers(IEnumerable<Assembly> assemblies)
        {
            this.SubscribeMessageHandlers(assemblies, this.RegisterHandlerType);
        }

        /// <summary>
        /// Subscribes all message handlers in the calling assembly
        /// </summary>
        public void SubscribeMessageHandlersInThisAssembly()
        {
            this.SubscribeMessageHandlersInThisAssembly(this.RegisterHandlerType);
        }

        /// <summary>
        /// Registers a handler type in the IoC container
        /// </summary>
        /// <param name="type">The handler type</param>
        protected abstract void RegisterHandlerType(Type type);
    }
}


text:
export interface Axis {
    min: number
    max: number
    length?: number
}

export interface Box {
    x: Axis
    y: Axis
}

export interface RelativeBox {
    x: Partial<Axis>
    y: Partial<Axis>
}

export interface BoundingBox {
    top: number
    right: number
    bottom: number
    left: number
}

export interface Point {
    x: number
    y: number
}

export interface AxisProjection {
    translate: number
    scale: number
    origin: number
    originPoint: number
}

export interface Projection {
    x: AxisProjection
    y: AxisProjection
}


text:
require 'rails_helper'

RSpec.describe Admin::Flags::NotifyUser do
  subject(:service) { described_class.call(admin:, flag:) }

  let(:admin) { create(:user, admin: true) }
  let(:flag) { create(:flag, project_submission:) }
  let(:project_submission) { create(:project_submission, user:) }
  let(:user) { create(:user) }

  describe '#call' do
    it 'sets the flags taken action to notified_user' do
      expect { service }.to change { flag.taken_action }.from('pending').to('notified_user')
    end

    it 'sets the flags status to resolved' do
      expect { service }.to change { flag.status }.from('active').to('resolved')
    end

    it 'sets the resolved_by_id to the id of the current admin user' do
      expect { service }.to change { flag.resolved_by_id }.from(nil).to(admin.id)
    end

    it 'creates a notification' do
      expect { service }.to change { Notification.count }.from(0).to(1)
    end

    it 'updates the flag\'s project submission to set a discard at date seven days in the future' do
      expect { service }.to change { project_submission.discard_at }.from(nil).to(7.days.from_now.all_day)
    end
  end
end


text:
using System.Reflection;
using System.Runtime.InteropServices;

[assembly: AssemblyTitle("Ab")]
[assembly: AssemblyProduct("Ab")]

[assembly: Guid("ee65aaee-2f06-4bc6-9148-f61fe30516d7")]

[assembly: AssemblyVersion("0.0.0.0")]
[assembly: AssemblyFileVersion("0.0.0.0")]


text:
#include "mbed_assert.h"
#include "i2c_api.h"

#if DEVICE_I2C

#include "cmsis.h"
#include "pinmap.h"
#include "fsl_lpi2c.h"
#include "PeripheralPins.h"

/* Array of I2C peripheral base address. */
static LPI2C_Type *const i2c_addrs[] = LPI2C_BASE_PTRS;

extern void i2c_setup_clock();
extern uint32_t i2c_get_clock();
void pin_mode_opendrain(PinName pin, bool enable);

void i2c_init(i2c_t *obj, PinName sda, PinName scl)
{
    uint32_t i2c_sda = pinmap_peripheral(sda, PinMap_I2C_SDA);
    uint32_t i2c_scl = pinmap_peripheral(scl, PinMap_I2C_SCL);
    obj->instance = pinmap_merge(i2c_sda, i2c_scl);

    MBED_ASSERT((int)obj->instance != NC);

    lpi2c_master_config_t master_config;

    i2c_setup_clock();

    LPI2C_MasterGetDefaultConfig(&master_config);
    LPI2C_MasterInit(i2c_addrs[obj->instance], &master_config, i2c_get_clock());

    pinmap_pinout(sda, PinMap_I2C_SDA);
    pinmap_pinout(scl, PinMap_I2C_SCL);

    pin_mode(sda, PullUp_22K);
    pin_mode(scl, PullUp_22K);

    pin_mode_opendrain(sda, true);
    pin_mode_opendrain(scl, true);
}

int i2c_start(i2c_t *obj)
{
    LPI2C_Type *base = i2c_addrs[obj->instance];
    int status = 0;

    obj->address_set = 0;

    /* Clear all flags. */
    LPI2C_MasterClearStatusFlags(base, kLPI2C_MasterEndOfPacketFlag |
                                       kLPI2C_MasterStopDetectFlag |
                                       kLPI2C_MasterNackDetectFlag |
                                       kLPI2C_MasterArbitrationLostFlag |
                                       kLPI2C_MasterFifoErrFlag |
                                       kLPI2C_MasterPinLowTimeoutFlag |
                                       kLPI2C_MasterDataMatchFlag);

    /* Turn off auto-stop option. */
    base->MCFGR1 &= ~LPI2C_MCFGR1_AUTOSTOP_MASK;

    return status;
}

int i2c_stop(i2c_t *obj)
{
    if (LPI2C_MasterStop(i2c_addrs[obj->instance]) != kStatus_Success) {
        return 1;
    }

    obj->address_set = 0;

    return 0;
}

void i2c_frequency(i2c_t *obj, int hz)
{
    uint32_t busClock;

    busClock = i2c_get_clock();
    LPI2C_MasterSetBaudRate(i2c_addrs[obj->instance], busClock, hz);
}

int i2c_read(i2c_t *obj, int address, char *data, int length, int stop)
{
    LPI2C_Type *base = i2c_addrs[obj->instance];
    lpi2c_master_transfer_t master_xfer;

    memset(&master_xfer, 0, sizeof(master_xfer));
    master_xfer.slaveAddress = address >> 1;
    master_xfer.direction = kLPI2C_Read;
    master_xfer.data = (uint8_t *)data;
    master_xfer.dataSize = length;
    if (!stop) {
        master_xfer.flags |= kLPI2C_TransferNoStopFlag;
    }

    /* The below function will issue a STOP signal at the end of the transfer.
     * This is required by the hardware in order to receive the last byte
     */
    if (LPI2C_MasterTransferBlocking(base, &master_xfer) != kStatus_Success) {
        return I2C_ERROR_NO_SLAVE;
    }

    return length;
}

int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop)
{
    LPI2C_Type *base = i2c_addrs[obj->instance];
    lpi2c_master_transfer_t master_xfer;

    if (length == 0) {
        if (LPI2C_MasterStart(base, address >> 1, kLPI2C_Write) != kStatus_Success) {
            return I2C_ERROR_NO_SLAVE;
        }

        /* Wait till START has been flushed out of the FIFO */
        while (!(base->MSR & kLPI2C_MasterBusBusyFlag)) {
        }

        /* Send the STOP signal */
        base->MTDR = LPI2C_MTDR_CMD(0x2U);

        /* Wait till STOP has been sent successfully */
        while (!(base->MSR & kLPI2C_MasterStopDetectFlag)) {
        }

        if (base->MSR & kLPI2C_MasterNackDetectFlag) {
            return I2C_ERROR_NO_SLAVE;
        } else {
            return length;
        }
    }

    memset(&master_xfer, 0, sizeof(master_xfer));
    master_xfer.slaveAddress = address >> 1;
    master_xfer.direction = kLPI2C_Write;
    master_xfer.data = (uint8_t *)data;
    master_xfer.dataSize = length;
    if (!stop) {
        master_xfer.flags |= kLPI2C_TransferNoStopFlag;
    }

    if (LPI2C_MasterTransferBlocking(base, &master_xfer) != kStatus_Success) {
        return I2C_ERROR_NO_SLAVE;
    }

    return length;
}

void i2c_reset(i2c_t *obj)
{
    i2c_stop(obj);
}

int i2c_byte_read(i2c_t *obj, int last)
{
    uint8_t data;
    LPI2C_Type *base = i2c_addrs[obj->instance];
    lpi2c_master_transfer_t master_xfer;

    memset(&master_xfer, 0, sizeof(master_xfer));
    master_xfer.direction = kLPI2C_Read;
    master_xfer.data = &data;
    master_xfer.dataSize = 1;
    master_xfer.flags = kLPI2C_TransferNoStopFlag | kLPI2C_TransferNoStartFlag;

    if (LPI2C_MasterTransferBlocking(base, &master_xfer) != kStatus_Success) {
        return I2C_ERROR_NO_SLAVE;
    }
    return data;
}

int i2c_byte_write(i2c_t *obj, int data)
{
    LPI2C_Type *base = i2c_addrs[obj->instance];
    uint32_t status;
    size_t txCount;
    size_t txFifoSize = FSL_FEATURE_LPI2C_FIFO_SIZEn(base);

    /* Clear error flags. */
    LPI2C_MasterClearStatusFlags(base, LPI2C_MasterGetStatusFlags(base));

    /* Wait till there is room in the TX FIFO */
    do {
        /* Get the number of words in the tx fifo and compute empty slots. */
        LPI2C_MasterGetFifoCounts(base, NULL, &txCount);
        txCount = txFifoSize - txCount;
    } while (!txCount);

    if (!obj->address_set) {
        obj->address_set  = 1;
        /* Issue start command. */
        base->MTDR = LPI2C_MTDR_CMD(0x4U) | LPI2C_MTDR_DATA(data);
    } else {
        /* Write byte into LPI2C master data register. */
        base->MTDR = data;
    }

    /* Wait till data is pushed out of the FIFO */
    while (!(base->MSR & kLPI2C_MasterTxReadyFlag)) {
    }

    status = LPI2C_MasterCheckAndClearError(base, LPI2C_MasterGetStatusFlags(base));
    if (status == kStatus_Success) {
        return 1;
    } else if (status == kStatus_LPI2C_Nak) {
        return 0;
    } else {
        return 2;
    }
}

const PinMap *i2c_master_sda_pinmap()
{
    return PinMap_I2C_SDA;
}

const PinMap *i2c_master_scl_pinmap()
{
    return PinMap_I2C_SCL;
}

const PinMap *i2c_slave_sda_pinmap()
{
    return PinMap_I2C_SDA;
}

const PinMap *i2c_slave_scl_pinmap()
{
    return PinMap_I2C_SCL;
}

#if DEVICE_I2CSLAVE
void i2c_slave_mode(i2c_t *obj, int enable_slave)
{
    lpi2c_slave_config_t slave_config;
    LPI2C_SlaveGetDefaultConfig(&slave_config);
    slave_config.enableSlave = (bool)enable_slave;

    LPI2C_SlaveInit(i2c_addrs[obj->instance], &slave_config, i2c_get_clock());
}

int i2c_slave_receive(i2c_t *obj)
{
    LPI2C_Type *base = i2c_addrs[obj->instance];
    uint32_t status_flags = LPI2C_SlaveGetStatusFlags(base);

    if (status_flags & kLPI2C_SlaveAddressValidFlag) {
        if (base->SASR & kLPI2C_Read) {
            // read addressed
            return 1;
        } else {
            // write addressed
            return 3;
        }
    } else {
        // slave not addressed
        return 0;
    }
}

int i2c_slave_read(i2c_t *obj, char *data, int length)
{
    LPI2C_Type *base = i2c_addrs[obj->instance];
    int actual_rx;

    LPI2C_SlaveReceive(base, (uint8_t *)data, length, (size_t *)&actual_rx);

    return actual_rx;
}

int i2c_slave_write(i2c_t *obj, const char *data, int length)
{
    LPI2C_Type *base = i2c_addrs[obj->instance];
    int actual_rx;

    LPI2C_SlaveSend(base, (uint8_t *)data, length, (size_t *)&actual_rx);

    return actual_rx;
}

void i2c_slave_address(i2c_t *obj, int idx, uint32_t address, uint32_t mask)
{
    i2c_addrs[obj->instance]->SAMR = LPI2C_SAMR_ADDR0(address & 0xfe);
}
#endif

#endif


text:
/*
* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
* THIS FILE MUST NOT BE EDITED BY HAND
 */

package require

import (
	assert "github.com/stretchr/testify/assert"
	http "net/http"
	url "net/url"
	time "time"
)

// Condition uses a Comparison to assert a complex condition.
func (a *Assertions) Condition(comp assert.Comparison, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Condition(a.t, comp, msgAndArgs...)
}

// Conditionf uses a Comparison to assert a complex condition.
func (a *Assertions) Conditionf(comp assert.Comparison, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Conditionf(a.t, comp, msg, args...)
}

// Contains asserts that the specified string, list(array, slice...) or map contains the
// specified substring or element.
//
//    a.Contains("Hello World", "World")
//    a.Contains(["Hello", "World"], "World")
//    a.Contains({"Hello": "World"}, "Hello")
func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Contains(a.t, s, contains, msgAndArgs...)
}

// Containsf asserts that the specified string, list(array, slice...) or map contains the
// specified substring or element.
//
//    a.Containsf("Hello World", "World", "error message %s", "formatted")
//    a.Containsf(["Hello", "World"], "World", "error message %s", "formatted")
//    a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted")
func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Containsf(a.t, s, contains, msg, args...)
}

// DirExists checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists.
func (a *Assertions) DirExists(path string, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	DirExists(a.t, path, msgAndArgs...)
}

// DirExistsf checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists.
func (a *Assertions) DirExistsf(path string, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	DirExistsf(a.t, path, msg, args...)
}

// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified
// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
// the number of appearances of each of them in both lists should match.
//
// a.ElementsMatch([1, 3, 2, 3], [1, 3, 3, 2])
func (a *Assertions) ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	ElementsMatch(a.t, listA, listB, msgAndArgs...)
}

// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified
// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
// the number of appearances of each of them in both lists should match.
//
// a.ElementsMatchf([1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted")
func (a *Assertions) ElementsMatchf(listA interface{}, listB interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	ElementsMatchf(a.t, listA, listB, msg, args...)
}

// Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
//  a.Empty(obj)
func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Empty(a.t, object, msgAndArgs...)
}

// Emptyf asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
//  a.Emptyf(obj, "error message %s", "formatted")
func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Emptyf(a.t, object, msg, args...)
}

// Equal asserts that two objects are equal.
//
//    a.Equal(123, 123)
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses). Function equality
// cannot be determined and will always fail.
func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Equal(a.t, expected, actual, msgAndArgs...)
}

// EqualError asserts that a function returned an error (i.e. not `nil`)
// and that it is equal to the provided error.
//
//   actualObj, err := SomeFunction()
//   a.EqualError(err,  expectedErrorString)
func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	EqualError(a.t, theError, errString, msgAndArgs...)
}

// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
// and that it is equal to the provided error.
//
//   actualObj, err := SomeFunction()
//   a.EqualErrorf(err,  expectedErrorString, "error message %s", "formatted")
func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	EqualErrorf(a.t, theError, errString, msg, args...)
}

// EqualValues asserts that two objects are equal or convertable to the same types
// and equal.
//
//    a.EqualValues(uint32(123), int32(123))
func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	EqualValues(a.t, expected, actual, msgAndArgs...)
}

// EqualValuesf asserts that two objects are equal or convertable to the same types
// and equal.
//
//    a.EqualValuesf(uint32(123, "error message %s", "formatted"), int32(123))
func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	EqualValuesf(a.t, expected, actual, msg, args...)
}

// Equalf asserts that two objects are equal.
//
//    a.Equalf(123, 123, "error message %s", "formatted")
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses). Function equality
// cannot be determined and will always fail.
func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Equalf(a.t, expected, actual, msg, args...)
}

// Error asserts that a function returned an error (i.e. not `nil`).
//
//   actualObj, err := SomeFunction()
//   if a.Error(err) {
// 	   assert.Equal(t, expectedError, err)
//   }
func (a *Assertions) Error(err error, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Error(a.t, err, msgAndArgs...)
}

// Errorf asserts that a function returned an error (i.e. not `nil`).
//
//   actualObj, err := SomeFunction()
//   if a.Errorf(err, "error message %s", "formatted") {
// 	   assert.Equal(t, expectedErrorf, err)
//   }
func (a *Assertions) Errorf(err error, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Errorf(a.t, err, msg, args...)
}

// Exactly asserts that two objects are equal in value and type.
//
//    a.Exactly(int32(123), int64(123))
func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Exactly(a.t, expected, actual, msgAndArgs...)
}

// Exactlyf asserts that two objects are equal in value and type.
//
//    a.Exactlyf(int32(123, "error message %s", "formatted"), int64(123))
func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Exactlyf(a.t, expected, actual, msg, args...)
}

// Fail reports a failure through
func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Fail(a.t, failureMessage, msgAndArgs...)
}

// FailNow fails test
func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	FailNow(a.t, failureMessage, msgAndArgs...)
}

// FailNowf fails test
func (a *Assertions) FailNowf(failureMessage string, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	FailNowf(a.t, failureMessage, msg, args...)
}

// Failf reports a failure through
func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Failf(a.t, failureMessage, msg, args...)
}

// False asserts that the specified value is false.
//
//    a.False(myBool)
func (a *Assertions) False(value bool, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	False(a.t, value, msgAndArgs...)
}

// Falsef asserts that the specified value is false.
//
//    a.Falsef(myBool, "error message %s", "formatted")
func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Falsef(a.t, value, msg, args...)
}

// FileExists checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file.
func (a *Assertions) FileExists(path string, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	FileExists(a.t, path, msgAndArgs...)
}

// FileExistsf checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file.
func (a *Assertions) FileExistsf(path string, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	FileExistsf(a.t, path, msg, args...)
}

// HTTPBodyContains asserts that a specified handler returns a
// body that contains a string.
//
//  a.HTTPBodyContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	HTTPBodyContains(a.t, handler, method, url, values, str, msgAndArgs...)
}

// HTTPBodyContainsf asserts that a specified handler returns a
// body that contains a string.
//
//  a.HTTPBodyContainsf(myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	HTTPBodyContainsf(a.t, handler, method, url, values, str, msg, args...)
}

// HTTPBodyNotContains asserts that a specified handler returns a
// body that does not contain a string.
//
//  a.HTTPBodyNotContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	HTTPBodyNotContains(a.t, handler, method, url, values, str, msgAndArgs...)
}

// HTTPBodyNotContainsf asserts that a specified handler returns a
// body that does not contain a string.
//
//  a.HTTPBodyNotContainsf(myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	HTTPBodyNotContainsf(a.t, handler, method, url, values, str, msg, args...)
}

// HTTPError asserts that a specified handler returns an error status code.
//
//  a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	HTTPError(a.t, handler, method, url, values, msgAndArgs...)
}

// HTTPErrorf asserts that a specified handler returns an error status code.
//
//  a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false).
func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	HTTPErrorf(a.t, handler, method, url, values, msg, args...)
}

// HTTPRedirect asserts that a specified handler returns a redirect status code.
//
//  a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	HTTPRedirect(a.t, handler, method, url, values, msgAndArgs...)
}

// HTTPRedirectf asserts that a specified handler returns a redirect status code.
//
//  a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false).
func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	HTTPRedirectf(a.t, handler, method, url, values, msg, args...)
}

// HTTPSuccess asserts that a specified handler returns a success status code.
//
//  a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	HTTPSuccess(a.t, handler, method, url, values, msgAndArgs...)
}

// HTTPSuccessf asserts that a specified handler returns a success status code.
//
//  a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	HTTPSuccessf(a.t, handler, method, url, values, msg, args...)
}

// Implements asserts that an object is implemented by the specified interface.
//
//    a.Implements((*MyInterface)(nil), new(MyObject))
func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Implements(a.t, interfaceObject, object, msgAndArgs...)
}

// Implementsf asserts that an object is implemented by the specified interface.
//
//    a.Implementsf((*MyInterface, "error message %s", "formatted")(nil), new(MyObject))
func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Implementsf(a.t, interfaceObject, object, msg, args...)
}

// InDelta asserts that the two numerals are within delta of each other.
//
// 	 a.InDelta(math.Pi, (22 / 7.0), 0.01)
func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	InDelta(a.t, expected, actual, delta, msgAndArgs...)
}

// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
func (a *Assertions) InDeltaMapValues(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	InDeltaMapValues(a.t, expected, actual, delta, msgAndArgs...)
}

// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
func (a *Assertions) InDeltaMapValuesf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	InDeltaMapValuesf(a.t, expected, actual, delta, msg, args...)
}

// InDeltaSlice is the same as InDelta, except it compares two slices.
func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...)
}

// InDeltaSlicef is the same as InDelta, except it compares two slices.
func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	InDeltaSlicef(a.t, expected, actual, delta, msg, args...)
}

// InDeltaf asserts that the two numerals are within delta of each other.
//
// 	 a.InDeltaf(math.Pi, (22 / 7.0, "error message %s", "formatted"), 0.01)
func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	InDeltaf(a.t, expected, actual, delta, msg, args...)
}

// InEpsilon asserts that expected and actual have a relative error less than epsilon
func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...)
}

// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...)
}

// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices.
func (a *Assertions) InEpsilonSlicef(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	InEpsilonSlicef(a.t, expected, actual, epsilon, msg, args...)
}

// InEpsilonf asserts that expected and actual have a relative error less than epsilon
func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	InEpsilonf(a.t, expected, actual, epsilon, msg, args...)
}

// IsType asserts that the specified objects are of the same type.
func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	IsType(a.t, expectedType, object, msgAndArgs...)
}

// IsTypef asserts that the specified objects are of the same type.
func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	IsTypef(a.t, expectedType, object, msg, args...)
}

// JSONEq asserts that two JSON strings are equivalent.
//
//  a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	JSONEq(a.t, expected, actual, msgAndArgs...)
}

// JSONEqf asserts that two JSON strings are equivalent.
//
//  a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	JSONEqf(a.t, expected, actual, msg, args...)
}

// Len asserts that the specified object has specific length.
// Len also fails if the object has a type that len() not accept.
//
//    a.Len(mySlice, 3)
func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Len(a.t, object, length, msgAndArgs...)
}

// Lenf asserts that the specified object has specific length.
// Lenf also fails if the object has a type that len() not accept.
//
//    a.Lenf(mySlice, 3, "error message %s", "formatted")
func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Lenf(a.t, object, length, msg, args...)
}

// Nil asserts that the specified object is nil.
//
//    a.Nil(err)
func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Nil(a.t, object, msgAndArgs...)
}

// Nilf asserts that the specified object is nil.
//
//    a.Nilf(err, "error message %s", "formatted")
func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Nilf(a.t, object, msg, args...)
}

// NoError asserts that a function returned no error (i.e. `nil`).
//
//   actualObj, err := SomeFunction()
//   if a.NoError(err) {
// 	   assert.Equal(t, expectedObj, actualObj)
//   }
func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NoError(a.t, err, msgAndArgs...)
}

// NoErrorf asserts that a function returned no error (i.e. `nil`).
//
//   actualObj, err := SomeFunction()
//   if a.NoErrorf(err, "error message %s", "formatted") {
// 	   assert.Equal(t, expectedObj, actualObj)
//   }
func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NoErrorf(a.t, err, msg, args...)
}

// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
// specified substring or element.
//
//    a.NotContains("Hello World", "Earth")
//    a.NotContains(["Hello", "World"], "Earth")
//    a.NotContains({"Hello": "World"}, "Earth")
func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NotContains(a.t, s, contains, msgAndArgs...)
}

// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
// specified substring or element.
//
//    a.NotContainsf("Hello World", "Earth", "error message %s", "formatted")
//    a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted")
//    a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted")
func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NotContainsf(a.t, s, contains, msg, args...)
}

// NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
//  if a.NotEmpty(obj) {
//    assert.Equal(t, "two", obj[1])
//  }
func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NotEmpty(a.t, object, msgAndArgs...)
}

// NotEmptyf asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
//  if a.NotEmptyf(obj, "error message %s", "formatted") {
//    assert.Equal(t, "two", obj[1])
//  }
func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NotEmptyf(a.t, object, msg, args...)
}

// NotEqual asserts that the specified values are NOT equal.
//
//    a.NotEqual(obj1, obj2)
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses).
func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NotEqual(a.t, expected, actual, msgAndArgs...)
}

// NotEqualf asserts that the specified values are NOT equal.
//
//    a.NotEqualf(obj1, obj2, "error message %s", "formatted")
//
// Pointer variable equality is determined based on the equality of the
// referenced values (as opposed to the memory addresses).
func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NotEqualf(a.t, expected, actual, msg, args...)
}

// NotNil asserts that the specified object is not nil.
//
//    a.NotNil(err)
func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NotNil(a.t, object, msgAndArgs...)
}

// NotNilf asserts that the specified object is not nil.
//
//    a.NotNilf(err, "error message %s", "formatted")
func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NotNilf(a.t, object, msg, args...)
}

// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
//
//   a.NotPanics(func(){ RemainCalm() })
func (a *Assertions) NotPanics(f assert.PanicTestFunc, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NotPanics(a.t, f, msgAndArgs...)
}

// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
//
//   a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted")
func (a *Assertions) NotPanicsf(f assert.PanicTestFunc, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NotPanicsf(a.t, f, msg, args...)
}

// NotRegexp asserts that a specified regexp does not match a string.
//
//  a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
//  a.NotRegexp("^start", "it's not starting")
func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NotRegexp(a.t, rx, str, msgAndArgs...)
}

// NotRegexpf asserts that a specified regexp does not match a string.
//
//  a.NotRegexpf(regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting")
//  a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted")
func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NotRegexpf(a.t, rx, str, msg, args...)
}

// NotSubset asserts that the specified list(array, slice...) contains not all
// elements given in the specified subset(array, slice...).
//
//    a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")
func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NotSubset(a.t, list, subset, msgAndArgs...)
}

// NotSubsetf asserts that the specified list(array, slice...) contains not all
// elements given in the specified subset(array, slice...).
//
//    a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NotSubsetf(a.t, list, subset, msg, args...)
}

// NotZero asserts that i is not the zero value for its type.
func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NotZero(a.t, i, msgAndArgs...)
}

// NotZerof asserts that i is not the zero value for its type.
func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	NotZerof(a.t, i, msg, args...)
}

// Panics asserts that the code inside the specified PanicTestFunc panics.
//
//   a.Panics(func(){ GoCrazy() })
func (a *Assertions) Panics(f assert.PanicTestFunc, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Panics(a.t, f, msgAndArgs...)
}

// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
// the recovered panic value equals the expected panic value.
//
//   a.PanicsWithValue("crazy error", func(){ GoCrazy() })
func (a *Assertions) PanicsWithValue(expected interface{}, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	PanicsWithValue(a.t, expected, f, msgAndArgs...)
}

// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
// the recovered panic value equals the expected panic value.
//
//   a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
func (a *Assertions) PanicsWithValuef(expected interface{}, f assert.PanicTestFunc, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	PanicsWithValuef(a.t, expected, f, msg, args...)
}

// Panicsf asserts that the code inside the specified PanicTestFunc panics.
//
//   a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted")
func (a *Assertions) Panicsf(f assert.PanicTestFunc, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Panicsf(a.t, f, msg, args...)
}

// Regexp asserts that a specified regexp matches a string.
//
//  a.Regexp(regexp.MustCompile("start"), "it's starting")
//  a.Regexp("start...$", "it's not starting")
func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Regexp(a.t, rx, str, msgAndArgs...)
}

// Regexpf asserts that a specified regexp matches a string.
//
//  a.Regexpf(regexp.MustCompile("start", "error message %s", "formatted"), "it's starting")
//  a.Regexpf("start...$", "it's not starting", "error message %s", "formatted")
func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Regexpf(a.t, rx, str, msg, args...)
}

// Subset asserts that the specified list(array, slice...) contains all
// elements given in the specified subset(array, slice...).
//
//    a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")
func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Subset(a.t, list, subset, msgAndArgs...)
}

// Subsetf asserts that the specified list(array, slice...) contains all
// elements given in the specified subset(array, slice...).
//
//    a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Subsetf(a.t, list, subset, msg, args...)
}

// True asserts that the specified value is true.
//
//    a.True(myBool)
func (a *Assertions) True(value bool, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	True(a.t, value, msgAndArgs...)
}

// Truef asserts that the specified value is true.
//
//    a.Truef(myBool, "error message %s", "formatted")
func (a *Assertions) Truef(value bool, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Truef(a.t, value, msg, args...)
}

// WithinDuration asserts that the two times are within duration delta of each other.
//
//   a.WithinDuration(time.Now(), time.Now(), 10*time.Second)
func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	WithinDuration(a.t, expected, actual, delta, msgAndArgs...)
}

// WithinDurationf asserts that the two times are within duration delta of each other.
//
//   a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	WithinDurationf(a.t, expected, actual, delta, msg, args...)
}

// Zero asserts that i is the zero value for its type.
func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Zero(a.t, i, msgAndArgs...)
}

// Zerof asserts that i is the zero value for its type.
func (a *Assertions) Zerof(i interface{}, msg string, args ...interface{}) {
	if h, ok := a.t.(tHelper); ok {
		h.Helper()
	}
	Zerof(a.t, i, msg, args...)
}


text:
local types = require "titan-compiler.types"

describe("Titan types", function()

    it("pretty-prints types", function()
        assert.same("{ integer }", types.tostring(types.Array(types.Integer())))
    end)

    -- TODO test vararg functions (types.Function with third argument as true)

    it("checks if a type is garbage collected", function()
        assert.truthy(types.is_gc(types.String()))
        assert.truthy(types.is_gc(types.Array(types.Integer())))
        assert.truthy(types.is_gc(types.Map(types.Integer(), types.Integer())))
        assert.truthy(types.is_gc(types.Function({}, {}, false)))
    end)

    it("compares identical functions", function()
        local f1 = types.Function({types.String(), types.Integer()}, {types.Boolean()}, false)
        local f2 = types.Function({types.String(), types.Integer()}, {types.Boolean()}, false)
        assert.truthy(types.equals(f1, f2))
    end)

    it("compares functions with different arguments", function()
        local f1 = types.Function({types.String(), types.Boolean()}, {types.Boolean()}, false)
        local f2 = types.Function({types.Integer(), types.Integer()}, {types.Boolean()}, false)
        assert.falsy(types.equals(f1, f2))
    end)

    it("compares functions with different returns", function()
        local f1 = types.Function({types.String(), types.Integer()}, {types.Boolean()}, false)
        local f2 = types.Function({types.String(), types.Integer()}, {types.Integer()}, false)
        assert.falsy(types.equals(f1, f2))
    end)

    it("compares functions of different input arity", function()
        local s = types.String()
        local f1 = types.Function({}, {s}, false)
        local f2 = types.Function({s}, {s}, false)
        local f3 = types.Function({s, s}, {s}, false)
        assert.falsy(types.equals(f1, f2))
        assert.falsy(types.equals(f2, f1))
        assert.falsy(types.equals(f2, f3))
        assert.falsy(types.equals(f3, f2))
        assert.falsy(types.equals(f1, f3))
        assert.falsy(types.equals(f3, f1))
    end)

    it("compares functions of different output arity", function()
        local s = types.String()
        local f1 = types.Function({s}, {}, false)
        local f2 = types.Function({s}, {s}, false)
        local f3 = types.Function({s}, {s, s}, false)
        assert.falsy(types.equals(f1, f2))
        assert.falsy(types.equals(f2, f1))
        assert.falsy(types.equals(f2, f3))
        assert.falsy(types.equals(f3, f2))
        assert.falsy(types.equals(f1, f3))
        assert.falsy(types.equals(f3, f1))
    end)

end)


text:
<form action="#" id="settings-tab" class="centered">

        Settings

    <button type="button" id="settings-tab-save-button">

        Save
    </button>
</form>