text:
package apple.avfoundation;

import apple.NSObject;
import apple.foundation.NSArray;
import apple.foundation.NSMethodSignature;
import apple.foundation.NSSet;
import apple.foundation.protocol.NSCopying;
import org.moe.natj.c.ann.FunctionPtr;
import org.moe.natj.general.NatJ;
import org.moe.natj.general.Pointer;
import org.moe.natj.general.ann.Generated;
import org.moe.natj.general.ann.Library;
import org.moe.natj.general.ann.Mapped;
import org.moe.natj.general.ann.MappedReturn;
import org.moe.natj.general.ann.NInt;
import org.moe.natj.general.ann.NUInt;
import org.moe.natj.general.ann.Owned;
import org.moe.natj.general.ann.Runtime;
import org.moe.natj.general.ptr.VoidPtr;
import org.moe.natj.objc.Class;
import org.moe.natj.objc.ObjCRuntime;
import org.moe.natj.objc.SEL;
import org.moe.natj.objc.ann.ObjCClassBinding;
import org.moe.natj.objc.ann.Selector;
import org.moe.natj.objc.map.ObjCObjectMapper;

/**
 * AVMetadataSalientObject
 *

 * AVMetadataSalientObject is a concrete subclass of AVMetadataObject defining the features of a salient object.
 *

 * AVMetadataSalientObject represents a single detected salient area in a picture. It is an immutable object describing
 * the salient object.
 *

 * On supported platforms, AVCaptureMetadataOutput outputs arrays of detected salient objects. See AVCaptureOutput.h.
 */
@Generated
@Library("AVFoundation")
@Runtime(ObjCRuntime.class)
@ObjCClassBinding
public class AVMetadataSalientObject extends AVMetadataObject implements NSCopying {
    static {
        NatJ.register();
    }

    @Generated
    protected AVMetadataSalientObject(Pointer peer) {
        super(peer);
    }

    @Generated
    @Selector("accessInstanceVariablesDirectly")
    public static native boolean accessInstanceVariablesDirectly();

    @Generated
    @Owned
    @Selector("alloc")
    public static native AVMetadataSalientObject alloc();

    @Owned
    @Generated
    @Selector("allocWithZone:")
    public static native AVMetadataSalientObject allocWithZone(VoidPtr zone);

    @Generated
    @Selector("automaticallyNotifiesObserversForKey:")
    public static native boolean automaticallyNotifiesObserversForKey(String key);

    @Generated
    @Selector("cancelPreviousPerformRequestsWithTarget:")
    public static native void cancelPreviousPerformRequestsWithTarget(@Mapped(ObjCObjectMapper.class) Object aTarget);

    @Generated
    @Selector("cancelPreviousPerformRequestsWithTarget:selector:object:")
    public static native void cancelPreviousPerformRequestsWithTargetSelectorObject(
            @Mapped(ObjCObjectMapper.class) Object aTarget, SEL aSelector,
            @Mapped(ObjCObjectMapper.class) Object anArgument);

    @Generated
    @Selector("classFallbacksForKeyedArchiver")
    public static native NSArray<String> classFallbacksForKeyedArchiver();

    @Generated
    @Selector("classForKeyedUnarchiver")
    public static native Class classForKeyedUnarchiver();

    @Generated
    @Owned
    @Selector("copyWithZone:")
    @MappedReturn(ObjCObjectMapper.class)
    public native Object copyWithZone(VoidPtr zone);

    @Generated
    @Selector("debugDescription")
    public static native String debugDescription_static();

    @Generated
    @Selector("description")
    public static native String description_static();

    @Generated
    @Selector("hash")
    @NUInt
    public static native long hash_static();

    @Generated
    @Selector("init")
    public native AVMetadataSalientObject init();

    @Generated
    @Selector("instanceMethodForSelector:")
    @FunctionPtr(name = "call_instanceMethodForSelector_ret")
    public static native NSObject.Function_instanceMethodForSelector_ret instanceMethodForSelector(SEL aSelector);

    @Generated
    @Selector("instanceMethodSignatureForSelector:")
    public static native NSMethodSignature instanceMethodSignatureForSelector(SEL aSelector);

    @Generated
    @Selector("instancesRespondToSelector:")
    public static native boolean instancesRespondToSelector(SEL aSelector);

    @Generated
    @Selector("isSubclassOfClass:")
    public static native boolean isSubclassOfClass(Class aClass);

    @Generated
    @Selector("keyPathsForValuesAffectingValueForKey:")
    public static native NSSet<String> keyPathsForValuesAffectingValueForKey(String key);

    @Generated
    @Owned
    @Selector("new")
    public static native AVMetadataSalientObject new_objc();

    /**
     * [@property] objectID
     *

     * A unique number associated with the receiver.
     *

     * The value of this property is an NSInteger indicating the unique identifier of this object in the picture. When a
     * new object enters the picture, it is assigned a new unique identifier. objectIDs are not re-used as object leave
     * the picture and new ones enter. Objects that leave the picture then re-enter are assigned a new objectID.
     */
    @Generated
    @Selector("objectID")
    @NInt
    public native long objectID();

    @Generated
    @Selector("resolveClassMethod:")
    public static native boolean resolveClassMethod(SEL sel);

    @Generated
    @Selector("resolveInstanceMethod:")
    public static native boolean resolveInstanceMethod(SEL sel);

    @Generated
    @Selector("setVersion:")
    public static native void setVersion_static(@NInt long aVersion);

    @Generated
    @Selector("superclass")
    public static native Class superclass_static();

    @Generated
    @Selector("version")
    @NInt
    public static native long version_static();
}


text:
This repository exists to hold all the build scripts along with a little
documentation so that users and developers alike can install their PyPWA or
any of the dependencies in for PyPWA with ease.

## Current Conda Install Scripts
Indentions are based on which packages are needed by which packages. For example
if you only want to install PyMultiNest, the packages you would need to install
are Cuba and MultiNest.

PyPWA
 * appdirs
 * iminuit
 * PyMultiNest
   * Cuba
   * MultiNest
 * pytest-cov
 * pytest-runner
   * hgtools
 * tabulate

## Notes:
1. If you are installing the software across multiple systems, compile the
	software on the oldest system first so that any libraries that are linked
	at compile time you know will work will all systems. It may result in
	slower execution, but at least you know it will run across all of your
	supported systems.
2. Conda doesn't have great documentation when it comes to shared object
	libraries, however conda does do a good job of filling the values you need
	in order for the libraries to compile correctly, you just need to make sure
	you have the proper libraries set to for build and install in the meta.yaml
	file followed by setting your prefixes correctly.
3. If your library uses cmake, use Condas cmake not your distros, it will
	reduce the chance of error without adding any complexity.
4. If your project uses blas, atlas, or lapack, consider using conda's mkl, its
	a math kernel library forked and optimized by Intel, and is the only place
	where you can get lapack from in anaconda without installing it yourself or
	using another users.

redpajama_set_name: RedPajamaGithub


text:
@interface BusinessEvaluateCell : UITableViewCell

@property (nonatomic, strong) UICollectionView *collectionView;

@end


text:
CPatrolPoint::CPatrolPoint									(const CPatrolPath *path)
{
#ifdef DEBUG
	m_path				= path;
	m_initialized		= false;
#endif
}

#ifdef DEBUG
void CPatrolPoint::verify_vertex_id							(const CLevelGraph *level_graph, const CGameLevelCrossTable *cross, const CGameGraph *game_graph) const
{
	if (!level_graph)
		return;

	if (level_graph->valid_vertex_id(m_level_vertex_id)) {
		return;
	}

	VERIFY			(m_path);
	string1024		temp;
	sprintf			(temp,"\n! Patrol point %s in path %s is not on the level graph vertex!",*m_name,*m_path->m_name);
	THROW2			(level_graph->valid_vertex_id(m_level_vertex_id),temp);
}
#endif

IC	void CPatrolPoint::correct_position						(const CLevelGraph *level_graph, const CGameLevelCrossTable *cross, const CGameGraph *game_graph)
{
	if (!level_graph || !level_graph->valid_vertex_position(position()) || !level_graph->valid_vertex_id(m_level_vertex_id))
		return;

	if (!level_graph->inside(level_vertex_id(level_graph,cross,game_graph),position()))
		m_position		= level_graph->vertex_position(level_vertex_id(level_graph,cross,game_graph));

	m_game_vertex_id	= cross->vertex(level_vertex_id(level_graph,cross,game_graph)).game_vertex_id();
}

CPatrolPoint::CPatrolPoint									(const CLevelGraph *level_graph, const CGameLevelCrossTable *cross, const CGameGraph *game_graph, const CPatrolPath *path, const Fvector &position, u32 level_vertex_id, u32 flags, shared_str name)
{
#ifdef DEBUG
	VERIFY				(path);
	m_path				= path;
#endif
	m_position			= position;
	m_level_vertex_id	= level_vertex_id;
	m_flags				= flags;
	m_name				= name;
#ifdef DEBUG
	m_initialized		= true;
#endif
	correct_position	(level_graph,cross,game_graph);
}

CPatrolPoint &CPatrolPoint::load_raw						(const CLevelGraph *level_graph, const CGameLevelCrossTable *cross, const CGameGraph *game_graph, IReader &stream)
{
	stream.r_fvector3	(m_position);
	m_flags				= stream.r_u32();
	stream.r_stringZ	(m_name);
	if (level_graph && level_graph->valid_vertex_position(m_position)) {
		Fvector				position = m_position;
		position.y			+= .15f;
		m_level_vertex_id	= level_graph->vertex_id(position);
	}
	else
		m_level_vertex_id	= u32(-1);
#ifdef DEBUG
	m_initialized		= true;
#endif
	correct_position	(level_graph,cross,game_graph);
	return				(*this);
}

void CPatrolPoint::load										(IReader &stream)
{
	load_data			(m_name,stream);
	load_data			(m_position,stream);
	load_data			(m_flags,stream);
	load_data			(m_level_vertex_id,stream);
	load_data			(m_game_vertex_id,stream);

#ifdef DEBUG
	m_initialized		= true;
#endif
}

void CPatrolPoint::save										(IWriter &stream)
{
	save_data			(m_name,stream);
	save_data			(m_position,stream);
	save_data			(m_flags,stream);
	save_data			(m_level_vertex_id,stream);
	save_data			(m_game_vertex_id,stream);
}

#ifdef XRGAME_EXPORTS
const u32 &CPatrolPoint::level_vertex_id					() const
{
	if (ai().game_graph().vertex(m_game_vertex_id)->level_id() == ai().level_graph().level_id())
		return			(level_vertex_id(&ai().level_graph(),&ai().cross_table(),&ai().game_graph()));

	return				(m_level_vertex_id);
}

const GameGraph::_GRAPH_ID &CPatrolPoint::game_vertex_id	() const
{
	if (ai().game_graph().vertex(m_game_vertex_id)->level_id() == ai().level_graph().level_id())
		return			(game_vertex_id(&ai().level_graph(),&ai().cross_table(),&ai().game_graph()));

	return				(m_game_vertex_id);
}
#endif


text:
<?php

namespace Fyb\Bundle\CoreBundle\Controller;

use Sylius\Bundle\ResourceBundle\Controller\ResourceController;
use Symfony\Component\Security\Core\Exception\AccessDeniedException;

class TaxonomyController extends ResourceController
{
    protected function isGrantedOr403($permission)
    {
        if (!$this->container->has('sylius.authorization_checker')) {
            return true;
        }

        $permission = $this->config->getPermission($permission);

        if ($permission) {
            $grant = sprintf('%s.%s.%s', $this->config->getBundlePrefix(), $this->config->getResourceName(), $permission);
            if ($this->get('sylius.authorization_checker')->isGranted(sprintf('fyb.catalog.%s', $permission))) {
                return true;
            }

            if (!$this->get('sylius.authorization_checker')->isGranted($grant)) {
                throw new AccessDeniedException(sprintf('Access denied to "%s" for "%s".', $grant, $this->getUser() ? $this->getUser()->getUsername() : 'anon.'));
            }
        }
    }

}


text:
Spree::PaymentMethod.class_eval do
  has_many :fees, class_name: 'Spree::PaymentMethodFee', foreign_key: 'payment_method_id'

  accepts_nested_attributes_for :fees, allow_destroy: true
end


text:
from constants import *
from pygame import Rect

def positionMatchesF (f, wz, wx, wy, x, y):
    return f.wz == wz and f.wx == wx and f.wy == wy and f.tx == x and f.ty == y

class WorldState:
    def __init__ (self):
        self.terrains, self.features = {}, {}
    def addTerrain (self, terrain):
        key = (terrain.wz, terrain.wx, terrain.wy)
        if key not in self.terrains:
            self.terrains[key] = []
        if key not in self.features:
            self.features[key] = []
        self.terrains[key].append(terrain)
    def addFeature (self, feature):
        key = (feature.wz, feature.wx, feature.wy)
        if key not in self.features:
            self.features[key] = []
        self.features[key].append(feature)
    def getTerrains (self, wz, wx, wy):
        return self.terrains[(wz, wx, wy)]
    def getTerrain (self, wz, wx, wy, tx, ty):
        for t in self.getTerrains(wz, wx, wy):
            if t.tx == tx and t.ty == ty: return t
        return None
    def getFeatures (self, wz, wx, wy):
        return self.features[(wz, wx, wy)]
    def removeFeature (self, wz, wx, wy, x, y):
        self.features[(wz, wx, wy)][:] = [f for f in self.features[(wz, wx, wy)] if f.tx != x or f.ty != y]

class TemporalState:
    def __init__ (self):
        self.hero = None
        self.projectiles, self.creatures, self.allies = [], [], []
        self.obstacles, self.waterObstacles, self.clearObstacles = [], [], []
        self.fakeObstacles, self.fakeWaterObstacles, self.pushables = [], [], []
        self.poisonObstacles, self.fakePoisonObstacles = [], []
        self.availableItems = [] # AvailableItem
        self.stairs, self.checkForStairs, self.gotMirror, self.gotWings = None, False, False, False
        self.doors = [] # (x, y, doorState, rect, number)
        self.timer = 0
    def clear (self):
        self.projectiles[:], self.creatures[:], self.allies = [], [], []
        self.obstacles[:], self.waterObstacles[:], self.clearObstacles[:] = [], [], []
        self.fakeObstacles[:], self.fakeWaterObstacles[:], self.pushables[:] = [], [], []
        self.poisonObstacles[:], self.fakePoisonObstacles[:] = [], []
        self.availableItems[:] = []
        self.stairs, self.checkForStairs, self.gotMirror, self.gotWings = None, False, False, False
        self.doors[:] = []
        self.timer = 0
    def getCreatureRects (self, itself = -1):
        creatureRects = []
        for idx, creature in enumerate(self.creatures):
            if idx != itself:
                creatureRects.append(creature.rect)
        return creatureRects
    def getObstacles (self, filter):
        retValue = []
        if filter & INCLUDE_OBSTACLES > 0:
            retValue += self.obstacles
            for door in self.doors:
                if not door.isOpen() and not door.isLocked(): retValue.append(door.rect)
        if filter & INCLUDE_WATER_OBSTACLES > 0: retValue += self.waterObstacles
        if filter & INCLUDE_PUSHABLES > 0:
            for pushable in self.pushables: retValue.append(pushable.rect)
        if filter & INCLUDE_FAKE_OBSTACLES > 0: retValue += self.fakeObstacles
        if filter & INCLUDE_FAKE_WATER_OBSTACLES > 0: retValue += self.fakeWaterObstacles
        if filter & INCLUDE_LOCKED_DOORS > 0:
            for door in self.doors:
                if door.isLocked(): retValue.append(door.rect)
        if filter & INCLUDE_CLEAR_OBSTACLES: retValue += self.clearObstacles
        if filter & INCLUDE_POISON_OBSTACLES > 0: retValue += self.poisonObstacles
        if filter & INCLUDE_FAKE_POISON_OBSTACLES > 0: retValue += self.fakePoisonObstacles
        return retValue
    def getLockedDoorRects (self):
        rects = []
        for door in self.doors:
            if door.isLocked():
                rects.append(door.rect)
            else:
                # this hack keeps the locked door indexes aligned with the door indexes in tempState
                rects.append(Rect(9999, 9999, 9, 9))
        return rects
    def getAvailableItemRects (self, visibleOnly=False):
        rects = []
        for availableItem in self.availableItems:
            if not visibleOnly or availableItem.showState == VISIBLE:
                rects.append(availableItem.rect)
        return rects
    def deleteAvailableItem (self, idx):
        # this "deletes" an available item without modifying the collection
        # this is done to preserve the item indexes in the collection
        self.availableItems[idx].showState = COLLECTED
    def incrementTimer (self):
        self.timer += 1
        if self.timer == 100:
            self.timer = 0

class PermanentState:
    def __init__ (self):
        self.wx, self.wy, self.wz = START_WX, START_WY, START_WZ # start location
        self.maxHp, self.maxAttack, self.maxDefense = 3, 1, 0 # combat values
        self.obtainedItems = [] # unique items already obtained as a list of AvailableItem objects
        self.unlockedDoors = [] # locked doors already opened as a list of tuples (wx, wy, wz, x, y)
        # DEBUG: currently unlock all heroes for testing purposes
        self.unlockedHeroes = ['H1', 'H2', 'H4', 'H5', 'H6', 'H8', 'H17'] # heroes unlocked
        # DEBUG: start out with a key
        self.keys = 1 # number of keys
    def alreadyObtained (self, wz, wx, wy, x, y):
        return (wz, wx, wy, x, y) in self.obtainedItems
    def obtain (self, x, y):
        self.obtainedItems.append((self.wz, self.wx, self.wy, x, y))
    def save (self):
        pass
    def load (self):
        pass

worldState = WorldState()
tempState = TemporalState()
permState = PermanentState()


text:
package app;

import java.io.IOException;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import app.entities.Category;
import app.entities.Product;
import app.entities.User;
import app.models.bindingModels.CategoryInfo;
import app.models.bindingModels.CategoryJsonInDto;
import app.models.bindingModels.ProductInRangeJsonDto;
import app.models.bindingModels.ProductJsonInDto;
import app.models.bindingModels.SuccessfullUserJsonDto;
import app.models.bindingModels.UserJsonInDto;
import app.models.bindingModels.UsersInfoDto;
import app.services.api.CategoryService;
import app.services.api.ProductService;
import app.services.api.UserService;
import app.utils.JsonParser;
import app.utils.Mapper;

@Component
public class ConsoleRunner implements CommandLineRunner{

	private final String EXPORT_PATH = System.getProperty("user.dir") + "/src/main/resources/files/json/output/";
	private final String IMPORT_PATH = "/files/json/input/";

	private UserService userService;
	private CategoryService categoryService;
	private ProductService productService;
    private JsonParser jsonParser;

	@Autowired
	public ConsoleRunner(UserService userService, CategoryService categoryService, ProductService productService, JsonParser jsonParser) {
		this.userService = userService;
		this.categoryService = categoryService;
		this.productService = productService;
		this.jsonParser = jsonParser;
	}

	@Override
	public void run(String... args) throws Exception {

		Scanner scanner = new Scanner(System.in);

		BigDecimal min;
		BigDecimal max;
		String command;
		while (true) {

			printMenu();

			command = scanner.nextLine();
			if (command.equals("exit")) {
				break;
			}

			switch (command) {
			case "init":
				initializeDatabase();
				break;
			case "1":
				System.out.println("Enter min price... ");
				min = new BigDecimal(scanner.nextLine());
				System.out.println("Enter max price... ");
				max = new BigDecimal(scanner.nextLine());
				exportProductsInGivenRange(min, max);
				break;
			case "2":
				exportSuccessfullySoldProducts();
				break;
			case "3":
				exportCategoriesByProductsCount();
				break;
			case "4":
				exportUserProductsInfo();
				break;
			default:
				break;
			}

		}
		scanner.close();

	}

	private void exportUserProductsInfo() {
		List<User> users = userService.findAllSuccessfullUser();
		for (User user : users) {
			Set<Product> productsToRemove = new HashSet<>();
			for (Product p : user.getSoldProducts()) {
				if (p.getBuyer() == null) {
					productsToRemove.add(p);
				}
			}
			for (Product p : productsToRemove) {
				user.getSoldProducts().remove(p);
			}
		}
		UsersInfoDto usersInfoToExport = Mapper.mapToUsersInfo(users);
		try {
			jsonParser.exportJson(usersInfoToExport, EXPORT_PATH + "UsersProductsInfo.json");
		} catch (IOException e) {
			System.out.println("ERROR during file write!");
		}
	}

	private void exportCategoriesByProductsCount() {
		List<Category> categories = categoryService.findAllByProductsCount();
		List<CategoryInfo> categoryToExport = Mapper.mapToCategoryInfoList(categories);
		try {
			jsonParser.exportJson(categoryToExport, EXPORT_PATH + "CategoryInfo.json");
		} catch (IOException e) {
			System.out.println("ERROR during file write!");
		}
	}

	private void exportSuccessfullySoldProducts() {
		List<User> users = userService.findAllSuccessfullUser();
		for (User user : users) {
			Set<Product> productsToRemove = new HashSet<>();
			for (Product p : user.getSoldProducts()) {
				if (p.getBuyer() == null) {
					productsToRemove.add(p);
				}
			}
			for (Product p : productsToRemove) {
				user.getSoldProducts().remove(p);
			}
		}
		List<SuccessfullUserJsonDto> usersToExport = Mapper.mapToList(users, SuccessfullUserJsonDto.class);
		try {
			jsonParser.exportJson(usersToExport, EXPORT_PATH + "SuccessfullUser.json");
		} catch (IOException e) {
			System.out.println("ERROR during file write!");
		}
	}

	private void exportProductsInGivenRange(BigDecimal min, BigDecimal max) {
		List<Product> products = productService.findProductsByPriceInGivenRange(min, max);
		List<ProductInRangeJsonDto> productsToExport = Mapper.mapToProductInRangeList(products);
		try {
			jsonParser.exportJson(productsToExport, EXPORT_PATH + "ProductsInRange.json");
		} catch (IOException e) {
			System.out.println("ERROR during file write!");
		}
	}

	private void printMenu() {
		System.out.println();
		System.out.println("exit = Exit");
		System.out.println("init = Initialize Database");
		System.out.println("1 = Products In Range");
		System.out.println("2 = Successfully Sold Products");
		System.out.println("3 = Categories By Products Count");
		System.out.println("4 = Users and Products");
		System.out.println();
	}

	public void initializeDatabase() {

		if (userService.count() > 0) {
			System.out.println("Database already initialized!");
			return;
		}

		List<UserJsonInDto> usersDtos = null;
		try {
			usersDtos = jsonParser.importJsonToList(UserJsonInDto.class, IMPORT_PATH + "users.json");
		} catch (IOException e) {
			System.out.println("EROR during read userJsonFile!");
		}
		userService.save(Mapper.mapToList(usersDtos, User.class));

		List<CategoryJsonInDto> categoriesDtos = null;
		try {
			categoriesDtos = jsonParser.importJsonToList(CategoryJsonInDto.class, IMPORT_PATH + "categories.json");
		} catch (IOException e) {
			System.out.println("EROR during read userJsonFile!");
		}
		categoryService.save(Mapper.mapToList(categoriesDtos, Category.class));

		List<ProductJsonInDto> productsDtos = null;
		try {
			productsDtos = jsonParser.importJsonToList(ProductJsonInDto.class, IMPORT_PATH + "products.json");
		} catch (IOException e) {
			System.out.println("EROR during read userJsonFile!");
		}

		List<User> users = userService.findAll();
		int maxIndex = users.size();
		Random random = new Random();
		List<Integer> skipIds = new ArrayList<>();
		for (int i = 0; i < 9; i++) {
			skipIds.add(random.nextInt(maxIndex));
		}
		List<Product> products = Mapper.mapToList(productsDtos, Product.class);

		int sellerId;
		int buyerId;
		for (Product product : products) {
			sellerId = random.nextInt(maxIndex);
			product.setSeller(users.get(sellerId));
			buyerId = random.nextInt(maxIndex);
			if (skipIds.contains(buyerId)) {
				continue;
			}
			while (sellerId == buyerId) {
				buyerId = random.nextInt(maxIndex);
			}
			product.setBuyer(users.get(buyerId));
		}
		productService.save(products);

		products = productService.findAll();
		List<Category> categories = categoryService.findAll();
		int categoryId;
		int maxCount;
		maxIndex = categories.size();
		for (Product product : products) {
			maxCount = random.nextInt(5);
			if (maxCount == 0) {
				maxCount = 3;
			}
			while (product.getCategories().size() < maxCount) {
				categoryId = random.nextInt(maxIndex);
				product.addCategory(categories.get(categoryId));
			}
		}
		productService.save(products);

	}

}


text:
using System;
using System.Collections.Generic;
using System.Diagnostics;
using Citect.Ampla.Framework;
using Citect.Ampla.Runtime.Data.Samples;
using Citect.Ampla.Runtime.Data.Streams;
using Citect.Common;

namespace Code.Sms
{
    public interface IFluentSms
    {
        IFluentSms Using(ISmsService service);
        IFluentTime IfTrue(ISampleStream stream);
    }

    public interface IFluentTime
    {
        IFluentAction Then();
        IFluentAction AfterDelay(TimeSpan delay);
    }

    public interface IFluentAction
    {
        IFluentAction SendMessage(string message);
        IFluentAction ToMobile(string mobile);

        IFluentTime And();
        void Evaluate(Project project, TimePeriod period);
    }

    public class SmsAction : IFluentSms
    {
        private ISmsService smsService;
        private ISampleStream ifStream;
        private TimeSpan timeline = TimeSpan.Zero;
        private readonly List<FluentAction> actions = new List<FluentAction>();
        private readonly string hostFullName;

        public SmsAction(Item host)
        {
            hostFullName = host.FullName;
        }

        public IFluentSms Using(ISmsService service)
        {
            smsService = service;
            return this;
        }

        public IFluentTime IfTrue(ISampleStream stream)
        {
            ifStream = stream;
            return CreateTime();
        }

        private FluentAction CreateAction(TimeSpan delay)
        {
            timeline = timeline.Add(delay);
            FluentAction action = new FluentAction(this, timeline);
            actions.Add(action);
            action.Priority = actions.Count;
            return action;
        }

        private FluentTime CreateTime()
        {
            return new FluentTime(this);
        }

        private void Evaluate(Project project, TimePeriod period)
        {
            if (ifStream == null)
            {
                Log("SmsAction: {0} is not monitoring a stream.", hostFullName);
            }

            bool result; // whether the result is true.
            DateTime timeStamp; // the time of the last result

            if (TryEvaluateSampleAt(ifStream, period.End, out result, out timeStamp))
            {
                if (result)
                {
                    List<FluentAction> list = new List<FluentAction>();
                    foreach (FluentAction action in actions)
                    {
                        if (action.ShouldSend(timeStamp, period))
                        {
                            list.Add(action);
                        }
                    }

                    foreach (FluentAction action in list)
                    {
                        action.ExecuteSend(smsService);
                    }
                }
            }
        }

        private bool TryEvaluateSampleAt(ISampleStream stream, DateTime time, out bool result, out DateTime timeStamp)
        {
            bool returnValue = false;
            result = false;
            timeStamp = DateTime.MinValue;

            ISample sample = stream[time];
            if (sample != null)
            {
                if (sample.IsGood)
                {
                    try
                    {
                        bool value = Convert.ToBoolean(sample.Value);
                        timeStamp = sample.TimeStamp;

                        result = value;
                        returnValue = true;
                    }
                    catch (Exception)
                    {
                        // swallow exceptions
                    }
                }
            }
            return returnValue;
        }

        private void Log(string format, params object[] args)
        {
            Citect.Common.Diagnostics.Write(TraceLevel.Warning, format, args);
        }

        private class FluentTime : IFluentTime
        {
            private readonly SmsAction parent;
            private FluentAction action;

            internal FluentTime(SmsAction parent)
            {
                this.parent = parent;
            }

            public IFluentAction Then()
            {
                action = parent.CreateAction(TimeSpan.Zero);
                return action;
            }

            public IFluentAction AfterDelay(TimeSpan delta)
            {
                action = parent.CreateAction(delta);
                return action;
            }
        }

        private class FluentAction : IFluentAction
        {
            public FluentAction(SmsAction parent, TimeSpan delay)
            {
                this.parent = parent;
                afterDelay = delay;
            }

            private readonly TimeSpan afterDelay;
            private readonly SmsAction parent;
            private string smsMessage;
            private readonly List<string> mobileList = new List<string>();

            public int Priority
            {
                get; set;
            }

            public bool ShouldSend(DateTime occuranceTime, TimePeriod period)
            {
                DateTime actionTime = occuranceTime.Add(afterDelay);
                return period.Includes(actionTime);
            }

            public IFluentAction SendMessage(string message)
            {
                smsMessage = message;
                return this;
            }

            public IFluentAction ToMobile(string mobile)
            {
                if (!string.IsNullOrEmpty(mobile))
                {
                    mobileList.Add(mobile);
                }
                return this;
            }

            public IFluentTime And()
            {
                return parent.CreateTime();
            }

            public void Evaluate(Project project, TimePeriod period)
            {
                parent.Evaluate(project, period);
            }

            public void ExecuteSend(ISmsService smsService)
            {
                foreach (string mobile in mobileList)
                {
                    smsService.SendSms(mobile, smsMessage);
                }
            }
        }
    }
}


text:
from django.shortcuts import render
from django.http import HttpResponse
from xbee_module.models import xbee_module

def index(request):
    return HttpResponse("this is not programming")

def program(request, xbee_module_id):
    xbee_module_instance = xbee_module.objects.get(pk=xbee_module_id)

    commands = {}
    if xbee_module.HIGH_ADDRESS in request.POST:
        commands[xbee_module.HIGH_ADDRESS] = request.POST[xbee_module.HIGH_ADDRESS]

    if xbee_module.LOW_ADDRESS in request.POST:
        commands[xbee_module.LOW_ADDRESS] = request.POST[xbee_module.LOW_ADDRESS]

    xbee_module_instance.send_command(commands)

    context = {'serial_output': "none",
               'xbee_module': xbee_module_instance}
    return render(request, "xbee_module/programModule.html", context)


text:
package transport

type Subscription struct {
	DataChan chan []byte
	ErrChan  chan error
	signal   chan struct{}
}

func (s *Subscription) ContinuePolling() {
	s.signal <- struct{}{}
}


text:
package com.easyhousing.dao;

import java.util.List;

import com.easyhousing.model.RentHousePic;

public interface RentHousePicDao {
	public void insertRentHousePic(RentHousePic u);
	public int deleteRentHousePic(RentHousePic u);
	public int updateRentHousePic(RentHousePic u);
	public List<String> selectRentHousePicByRentHouseId(int id);
}


text:
package com.nanovash.better2048;

import javax.swing.*;
import javax.swing.GroupLayout.Alignment;
import javax.swing.LayoutStyle.ComponentPlacement;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import java.util.List;
import java.util.Timer;

public class Better2048 extends JFrame implements ComponentListener, ActionListener {

    static Better2048 frame;
    static TileCanvas game;
    static JPanel stats;
    static JLabel currentScore;
    static JLabel currentHighestTile;
    static JLabel highScore;
    static JLabel highestTile;
    static JTextField lengthField;
    static JCheckBox discoBox;
    static JComboBox<Object> comboBox;
    static JButton restartGame;
    static Properties props;
    static File saveFile;

    public static void main(String[] args) {
        EventQueue.invokeLater(() -> {
            try {
                frame = new Better2048();
                frame.setVisible(true);
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
    }

    public Better2048() throws IOException {
        frame = this;
        addComponentListener(this);
        setTitle("Better2048");
        setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
        setSize(828, 700);
        setMinimumSize(new Dimension(700, 700));
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent event) {
                save();
                frame.dispose();
                System.exit(0);
            }
        });

        discoBox = new JCheckBox("Disco - Off");
        discoBox.setForeground(Color.WHITE);
        discoBox.setBackground(Color.BLACK);
        discoBox.setToolTipText("Toggle disco mode where tiles get a random color when connected or created");
        discoBox.addActionListener(arg -> {
            if(discoBox.isSelected())
                discoBox.setText("Disco - On");
            else
                discoBox.setText("Disco - Off");
            game.requestFocusInWindow();
        });

        game = new TileCanvas();

        stats = new JPanel();
        stats.setBorder(BorderFactory.createMatteBorder(0, 1, 0, 0, Color.BLACK));
        stats.setBackground(Color.GRAY);
        GroupLayout groupLayout = new GroupLayout(getContentPane());
        groupLayout.setHorizontalGroup(
                groupLayout.createParallelGroup(Alignment.TRAILING)
                        .addGroup(groupLayout.createSequentialGroup()
                                .addComponent(game, GroupLayout.PREFERRED_SIZE, 529, Short.MAX_VALUE)
                                .addComponent(stats, GroupLayout.PREFERRED_SIZE, 149, GroupLayout.PREFERRED_SIZE))
        );
        groupLayout.setVerticalGroup(
                groupLayout.createParallelGroup(Alignment.TRAILING)
                        .addComponent(stats, GroupLayout.PREFERRED_SIZE, 661, Short.MAX_VALUE)
                        .addComponent(game, Alignment.LEADING, GroupLayout.DEFAULT_SIZE, 661, Short.MAX_VALUE)
        );

        JLabel labelCurrentScore = createJLabel("Current Score:", false);
        JLabel lblCurrentHighestTile = createJLabel("Current Highest Tile:", false);
        JLabel lblHighScore = createJLabel("High Score:", false);
        JLabel lblHighestTile = createJLabel("Highest Tile:", false);
        JLabel lblTileCanvasLength = createJLabel("Tile Canvas Length:", false);
        JLabel lblDiscoMode = createJLabel("Disco Mode:", false);
        JLabel lblTileMovingSpeed = createJLabel("Tile Moving Speed:", false);
        currentScore = createJLabel("Shows your current score", true);
        currentHighestTile = createJLabel("Shows your current highest tile", true);
        highScore = createJLabel("Shows your high score", true);
        highestTile = createJLabel("Shows your highest tile", true);

        restartGame = new JButton("Restart Game");
        restartGame.setToolTipText("Click to restart the game");
        restartGame.setForeground(Color.WHITE);
        restartGame.setBackground(Color.BLACK);
        restartGame.addActionListener(this);

        lengthField = new JTextField();
        lengthField.setSelectedTextColor(Color.WHITE);
        lengthField.setBackground(Color.BLACK);
        lengthField.setForeground(Color.WHITE);
        lengthField.setToolTipText("Change the number to set the length of the tile canvas");
        lengthField.setText("4");
        lengthField.setColumns(10);
        lengthField.setHorizontalAlignment(JTextField.CENTER);

        String[] options = new String[] {"Very Fast", "Fast", "Normal", "Slow","Very Slow"};
        comboBox = new JComboBox<Object>(options);
        comboBox.setBackground(Color.BLACK);
        comboBox.setForeground(Color.WHITE);
        comboBox.setSelectedIndex(2);
        comboBox.setToolTipText("Choose how fast you want the tiles to move");
        comboBox.addActionListener(e -> {
            game.requestFocusInWindow();
            Dimension d = getSize();
            double i = (double) d.height / 664;
            double j = (double) d.width / 664;
            switch(comboBox.getSelectedItem().toString()) {
                case "Very Fast":
                    TileCanvas.verticSpeed = (double) 300 / i;
                    TileCanvas.horizSpeed = (double) 300 / j;
                    break;
                case "Fast":
                    TileCanvas.verticSpeed = (double) 600 / i;
                    TileCanvas.horizSpeed = (double) 600 / j;
                    break;
                case "Normal":
                    TileCanvas.verticSpeed =  (double) 900 / i;
                    TileCanvas.horizSpeed = (double) 900 / j;
                    break;
                case "Slow":
                    TileCanvas.verticSpeed = (double) 1200 / i;
                    TileCanvas.horizSpeed = (double) 1200 / j;
                    break;
                case "Very Slow":
                    TileCanvas.verticSpeed = (double) 1500 / i;
                    TileCanvas.horizSpeed = (double) 1500 / j;
            }
        });

        GroupLayout gl_stats = new GroupLayout(stats);
        gl_stats.setHorizontalGroup(
                gl_stats.createParallelGroup(Alignment.TRAILING)
                        .addGroup(gl_stats.createSequentialGroup()
                                .addGroup(gl_stats.createParallelGroup(Alignment.LEADING)
                                        .addGroup(gl_stats.createSequentialGroup()
                                                .addContainerGap()
                                                .addComponent(lengthField, GroupLayout.DEFAULT_SIZE, 128, Short.MAX_VALUE))
                                        .addComponent(labelCurrentScore)
                                        .addGroup(gl_stats.createSequentialGroup()
                                                .addGap(10)
                                                .addComponent(currentScore, GroupLayout.DEFAULT_SIZE, 128, Short.MAX_VALUE))
                                        .addGroup(gl_stats.createSequentialGroup()
                                                .addContainerGap()
                                                .addComponent(restartGame, GroupLayout.DEFAULT_SIZE, 128, Short.MAX_VALUE))
                                        .addComponent(lblCurrentHighestTile)
                                        .addGroup(gl_stats.createSequentialGroup()
                                                .addContainerGap()
                                                .addComponent(currentHighestTile, GroupLayout.DEFAULT_SIZE, 128, Short.MAX_VALUE))
                                        .addComponent(lblHighScore)
                                        .addGroup(gl_stats.createSequentialGroup()
                                                .addContainerGap()
                                                .addComponent(highScore, GroupLayout.DEFAULT_SIZE, 128, Short.MAX_VALUE))
                                        .addComponent(lblHighestTile)
                                        .addGroup(gl_stats.createSequentialGroup()
                                                .addContainerGap()
                                                .addComponent(highestTile, GroupLayout.DEFAULT_SIZE, 128, Short.MAX_VALUE))
                                        .addComponent(lblTileCanvasLength)
                                        .addGroup(gl_stats.createSequentialGroup()
                                                .addGap(10)
                                                .addComponent(discoBox, GroupLayout.DEFAULT_SIZE, 128, Short.MAX_VALUE))
                                        .addComponent(lblDiscoMode)
                                        .addComponent(lblTileMovingSpeed)
                                        .addGroup(gl_stats.createSequentialGroup()
                                                .addContainerGap()
                                                .addComponent(comboBox, 0, 128, Short.MAX_VALUE)))
                                .addContainerGap())
        );
        gl_stats.setVerticalGroup(
                gl_stats.createParallelGroup(Alignment.LEADING)
                        .addGroup(gl_stats.createSequentialGroup()
                                .addComponent(labelCurrentScore)
                                .addPreferredGap(ComponentPlacement.RELATED)
                                .addComponent(currentScore, GroupLayout.PREFERRED_SIZE, 25, GroupLayout.PREFERRED_SIZE)
                                .addGap(18)
                                .addComponent(lblCurrentHighestTile)
                                .addPreferredGap(ComponentPlacement.RELATED)
                                .addComponent(currentHighestTile, GroupLayout.PREFERRED_SIZE, 24, GroupLayout.PREFERRED_SIZE)
                                .addGap(18)
                                .addComponent(lblHighScore)
                                .addPreferredGap(ComponentPlacement.RELATED)
                                .addComponent(highScore, GroupLayout.PREFERRED_SIZE, 25, GroupLayout.PREFERRED_SIZE)
                                .addGap(18)
                                .addComponent(lblHighestTile)
                                .addPreferredGap(ComponentPlacement.RELATED)
                                .addComponent(highestTile, GroupLayout.PREFERRED_SIZE, 27, GroupLayout.PREFERRED_SIZE)
                                .addGap(18)
                                .addComponent(lblTileCanvasLength)
                                .addPreferredGap(ComponentPlacement.RELATED)
                                .addComponent(lengthField, GroupLayout.PREFERRED_SIZE, 27, GroupLayout.PREFERRED_SIZE)
                                .addGap(18)
                                .addComponent(lblDiscoMode)
                                .addGap(7)
                                .addComponent(discoBox)
                                .addGap(18)
                                .addComponent(lblTileMovingSpeed)
                                .addPreferredGap(ComponentPlacement.RELATED)
                                .addComponent(comboBox, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE)
                                .addPreferredGap(ComponentPlacement.RELATED, 97, Short.MAX_VALUE)
                                .addComponent(restartGame, GroupLayout.PREFERRED_SIZE, 133, GroupLayout.PREFERRED_SIZE)
                                .addContainerGap())
        );
        stats.setLayout(gl_stats);
        getContentPane().setLayout(groupLayout);
        game.requestFocusInWindow();
        new Thread() {
            @Override
            public void run() {
                new Timer().schedule(new TimerTask() {
                    @Override
                    public void run() {
                        restartGame.doClick();
                    }
                }, 10L);
            }
        }.start();
        props = new Properties();
        File f = new File(System.getenv("Appdata"), ".better2048");
        if(!f.exists())
            f.mkdirs();
        saveFile = new File(f, "better2048.properties");
        if(!saveFile.exists())
            saveFile.createNewFile();
        load();
    }

    @Override
    public void componentResized(ComponentEvent ce) {
        game.setPreferredSize(new Dimension(getSize().width - 164, getSize().height - 36));
    }

    private void save() {
        try {
            OutputStream os = new FileOutputStream(saveFile);
            props.setProperty("highScore" + TileCanvas.canvasLength, highScore.getText());
            props.setProperty("highestTile" + TileCanvas.canvasLength, highestTile.getText());
            props.store(os, "Better2048's highscore saving file");
            os.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void load() {
        try {
            InputStream is = new FileInputStream(saveFile);
            props.load(is);
            is.close();
            if(props.getProperty("highScore" + TileCanvas.canvasLength) != null && props.getProperty("highestTile" + TileCanvas.canvasLength) != null) {
                highScore.setText(props.getProperty("highScore" + TileCanvas.canvasLength));
                highestTile.setText(props.getProperty("highestTile" + TileCanvas.canvasLength));
            }
            else {
                highScore.setText("0");
                highestTile.setText("0");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        TileCanvas.isShowingWin = false;
        TileCanvas.alreadyWon = false;
        TileCanvas.isGameOver = false;
        TileCanvas.lossLabel.setVisible(false);
        TileCanvas.winLabel.setVisible(false);
        save();
        for(int i = 0; i < TileCanvas.canvasLength; i++)
            for(int j = 0; j < TileCanvas.canvasLength; j++)
                if(TileCanvas.verticLocs.get(i).get(j) != null)
                    TileCanvas.verticLocs.get(i).get(j).destroy();
        lengthField.setText(Integer.toString(TileCanvas.canvasLength = (lengthField.getText().matches("[1-9][0-9]*") ? Integer.parseInt(lengthField.getText()) : 4)));
        int smaller = game.getPreferredSize().width < game.getPreferredSize().height ? game.getPreferredSize().width : game.getPreferredSize().height;
        if(TileCanvas.canvasLength == 1) {
            TileCanvas.canvasLength = 4;
            lengthField.setText("4");
        }
        else if(Integer.parseInt(lengthField.getText()) > smaller) {
            TileCanvas.canvasLength = smaller;
            lengthField.setText(Integer.toString(smaller));
        }
        currentScore.setText("0");
        currentHighestTile.setText("0");
        TileCanvas.verticLocs.clear();
        TileCanvas.horizLocs.clear();
        for(int i = 0; i < TileCanvas.canvasLength; i++) {
            List<Tile> temp1 = new ArrayList<Tile>();
            List<Tile> temp2 = new ArrayList<Tile>();
            for(int j = 0; j < TileCanvas.canvasLength; j++) {
                temp1.add(null);
                temp2.add(null);
            }
            TileCanvas.verticLocs.add(temp1);
            TileCanvas.horizLocs.add(temp2);
        }
        game.requestFocusInWindow();
        load();
        TileCanvas.createNewTile();
        TileCanvas.createNewTile();
    }

    public JLabel createJLabel(String text, boolean global) {
        JLabel label = new JLabel(global ? "0" : text);
        label.setOpaque(true);
        label.setForeground(Color.WHITE);
        label.setBackground(Color.BLACK);
        if(global) {
            label.setToolTipText(text);
            label.setHorizontalAlignment(JLabel.CENTER);
        }
        return label;
    }

    @Override
    public void componentHidden(ComponentEvent arg0) {}

    @Override
    public void componentMoved(ComponentEvent arg0) {}

    @Override
    public void componentShown(ComponentEvent arg0) {}
}


text:
Hazm
====

Python library for digesting Persian text.

+ Text cleaning
+ Sentence and word tokenizer
+ Word lemmatizer
+ POS tagger
+ Shallow parser
+ Dependency parser
+ Interfaces for Persian corpora
+ [NLTK](http://nltk.org/) compatible
+ Python 2.7, 3.2, 3.3, 3.4 and 3.5 support
+ [![Build Status](https://travis-ci.org/sobhe/hazm.png)](https://travis-ci.org/sobhe/hazm)

## Usage

```python
>>> from __future__ import unicode_literals
>>> from hazm import *

>>> normalizer = Normalizer()
>>> normalizer.normalize('اصلاح نويسه ها و استفاده از نیم‌فاصله پردازش را آسان مي كند')
'اصلاح نویسه‌ها و استفاده از نیم‌فاصله پردازش را آسان می‌کند'

>>> sent_tokenize('ما هم برای وصل کردن آمدیم! ولی برای پردازش، جدا بهتر نیست؟')
['ما هم برای وصل کردن آمدیم!', 'ولی برای پردازش، جدا بهتر نیست؟']
>>> word_tokenize('ولی برای پردازش، جدا بهتر نیست؟')
['ولی', 'برای', 'پردازش', '،', 'جدا', 'بهتر', 'نیست', '؟']

>>> stemmer = Stemmer()
>>> stemmer.stem('کتاب‌ها')
'کتاب'
>>> lemmatizer = Lemmatizer()
>>> lemmatizer.lemmatize('می‌روم')
'رفت#رو'

>>> tagger = POSTagger(model='resources/postagger.model')
>>> tagger.tag(word_tokenize('ما بسیار کتاب می‌خوانیم'))
[('ما', 'PRO'), ('بسیار', 'ADV'), ('کتاب', 'N'), ('می‌خوانیم', 'V')]

>>> chunker = Chunker(model='resources/chunker.model')
>>> tagged = tagger.tag(word_tokenize('کتاب خواندن را دوست داریم'))
>>> tree2brackets(chunker.parse(tagged))
'[کتاب خواندن NP] [را POSTP] [دوست داریم VP]'

>>> parser = DependencyParser(tagger=tagger, lemmatizer=lemmatizer)
>>> parser.parse(word_tokenize('زنگ‌ها برای که به صدا درمی‌آید؟'))
<DependencyGraph with 8 nodes>

```

## Installation

	pip install hazm

We have also trained [tagger and parser models](https://github.com/sobhe/hazm/releases/download/v0.5/resources-0.5.zip). You may put these models in the `resources` folder of your project.

## Extensions

Note: These are not official versions of hazm, not uptodate on functionality and are not supported by Sobhe.

+ [**JHazm**](https://github.com/mojtaba-khallash/JHazm): A Java port of Hazm
+ [**NHazm**](https://github.com/mojtaba-khallash/NHazm): A C# port of Hazm

## Thanks

+ to constributors: [Mojtaba Khallash](https://github.com/mojtaba-khallash) and [Mohsen Imany](https://github.com/imani).
+ to [Virastyar](http://virastyar.ir/) project for persian word list.


text:
require 'spec_helper'

describe ContainerRegistry::Blob do
  let(:digest) { 'sha256:0123456789012345' }
  let(:config) do
    {
      'digest' => digest,
      'mediaType' => 'binary',
      'size' => 1000
    }
  end

  let(:registry) { ContainerRegistry::Registry.new('http://example.com') }
  let(:repository) { registry.repository('group/test') }
  let(:blob) { repository.blob(config) }

  it { expect(blob).to respond_to(:repository) }
  it { expect(blob).to delegate_method(:registry).to(:repository) }
  it { expect(blob).to delegate_method(:client).to(:repository) }

  context '#path' do
    subject { blob.path }

    it { is_expected.to eq('example.com/group/test@sha256:0123456789012345') }
  end

  context '#digest' do
    subject { blob.digest }

    it { is_expected.to eq(digest) }
  end

  context '#type' do
    subject { blob.type }

    it { is_expected.to eq('binary') }
  end

  context '#revision' do
    subject { blob.revision }

    it { is_expected.to eq('0123456789012345') }
  end

  context '#short_revision' do
    subject { blob.short_revision }

    it { is_expected.to eq('012345678') }
  end

  context '#delete' do
    before do
      stub_request(:delete, 'http://example.com/v2/group/test/blobs/sha256:0123456789012345').
        to_return(status: 200)
    end

    subject { blob.delete }

    it { is_expected.to be_truthy }
  end
end


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Cenangium negerianum Henn.

### Remarks
null